66 makeTagged ,
77 passStyleOf ,
88} from '@agoric/marshal' ;
9- import { compareRank , sortByRank } from '../patterns/rankOrder.js' ;
9+ import { compareAntiRank , sortByRank } from '../patterns/rankOrder.js' ;
1010import { checkCopySetKeys } from './copySet.js' ;
1111
1212// eslint-disable-next-line spaced-comment
@@ -15,7 +15,7 @@ import { checkCopySetKeys } from './copySet.js';
1515const { details : X } = assert ;
1616const { ownKeys } = Reflect ;
1717
18- /** @type WeakSet<CopyMap> */
18+ /** @type WeakSet<CopyMap<any,any> > */
1919const copyMapMemo = new WeakSet ( ) ;
2020
2121/**
@@ -63,49 +63,105 @@ export const assertCopyMap = m => checkCopyMap(m, assertChecker);
6363harden ( assertCopyMap ) ;
6464
6565/**
66- * @param { CopyMap } m
67- * @param {(v: Passable, i: number) => boolean } fn
68- * @returns {boolean }
66+ * @template K,V
67+ * @param {CopyMap<K,V> } m
68+ * @returns {K[] }
6969 */
70- export const everyCopyMapKey = ( m , fn ) => {
70+ export const getCopyMapKeys = m => {
7171 assertCopyMap ( m ) ;
72- return m . payload . keys . every ( ( v , i ) => fn ( v , i ) ) ;
72+ return m . payload . keys ;
7373} ;
74- harden ( everyCopyMapKey ) ;
74+ harden ( getCopyMapKeys ) ;
7575
7676/**
77- * @param { CopyMap } m
78- * @param {(v: Passable, i: number) => boolean } fn
79- * @returns {boolean }
77+ * @template K,V
78+ * @param {CopyMap<K,V> } m
79+ * @returns {V[] }
8080 */
81- export const everyCopyMapValue = ( m , fn ) => {
81+ export const getCopyMapValues = m => {
8282 assertCopyMap ( m ) ;
83- return m . payload . values . every ( ( v , i ) => fn ( v , i ) ) ;
83+ return m . payload . values ;
8484} ;
85+ harden ( getCopyMapValues ) ;
86+
87+ /**
88+ * @template K,V
89+ * @param {CopyMap<K,V> } m
90+ * @returns {Iterable<[K,V]> }
91+ */
92+ export const getCopyMapEntries = m => {
93+ assertCopyMap ( m ) ;
94+ const {
95+ payload : { keys, values } ,
96+ } = m ;
97+ const { length } = keys ;
98+ return harden ( {
99+ [ Symbol . iterator ] : ( ) => {
100+ let i = 0 ;
101+ return harden ( {
102+ next : ( ) => {
103+ /** @type {IteratorResult<[K,V],void> } */
104+ let result ;
105+ if ( i < length ) {
106+ result = harden ( { done : false , value : [ keys [ i ] , values [ i ] ] } ) ;
107+ i += 1 ;
108+ return result ;
109+ } else {
110+ result = harden ( { done : true , value : undefined } ) ;
111+ }
112+ return result ;
113+ } ,
114+ } ) ;
115+ } ,
116+ } ) ;
117+ } ;
118+ harden ( getCopyMapEntries ) ;
119+
120+ /**
121+ * @template K,V
122+ * @param {CopyMap<K,V> } m
123+ * @param {(key: K, index: number) => boolean } fn
124+ * @returns {boolean }
125+ */
126+ export const everyCopyMapKey = ( m , fn ) =>
127+ getCopyMapKeys ( m ) . every ( ( key , index ) => fn ( key , index ) ) ;
128+ harden ( everyCopyMapKey ) ;
129+
130+ /**
131+ * @template K,V
132+ * @param {CopyMap<K,V> } m
133+ * @param {(value: V, index: number) => boolean } fn
134+ * @returns {boolean }
135+ */
136+ export const everyCopyMapValue = ( m , fn ) =>
137+ getCopyMapValues ( m ) . every ( ( value , index ) => fn ( value , index ) ) ;
85138harden ( everyCopyMapValue ) ;
86139
87140/**
88- * @param {CopyMap } m
89- * @returns {CopySet }
141+ * @template K,V
142+ * @param {CopyMap<K,V> } m
143+ * @returns {CopySet<K> }
90144 */
91145export const copyMapKeySet = m =>
92146 // A copyMap's keys are already in the internal form used by copySets.
93147 makeTagged ( 'copySet' , m . payload . keys ) ;
94148harden ( copyMapKeySet ) ;
95149
96150/**
97- * @param {Iterable<[Passable, Passable]> } entries
98- * @returns {CopyMap }
151+ * @template K,V
152+ * @param {Iterable<[K, V]> } entries
153+ * @returns {CopyMap<K,V> }
99154 */
100155export const makeCopyMap = entries => {
101156 // This is weird, but reverse rank sorting the entries is a good first step
102157 // for getting the rank sorted keys together with the values
103158 // organized by those keys. Also, among values associated with
104- // keys in the same equivalence class, those are rank sorted. This
159+ // keys in the same equivalence class, those are rank sorted.
160+ // TODO This
105161 // could solve the copyMap cover issue explained in patternMatchers.js.
106162 // But only if we include this criteria in our validation of copyMaps,
107163 // which we currently do not.
108- const sortedEntries = [ ... sortByRank ( entries , compareRank ) ] . reverse ( ) ;
164+ const sortedEntries = sortByRank ( entries , compareAntiRank ) ;
109165 const keys = sortedEntries . map ( ( [ k , _v ] ) => k ) ;
110166 const values = sortedEntries . map ( ( [ _k , v ] ) => v ) ;
111167 return makeTagged ( 'copyMap' , { keys, values } ) ;
0 commit comments