1  contract Maps =
  2  
  3    record pt    = {x : int, y : int}
  4    record state = { map_i : map(int, pt),
  5                     map_s : map(string, pt) }
  6  
  7    entrypoint init() = { map_i = {}, map_s = {} }
  8  
  9    entrypoint get_state() = state
 10  
 11    // {[k] = v}
 12    entrypoint map_i() =
 13      { [1] = {x = 1, y = 2},
 14        [2] = {x = 3, y = 4},
 15        [3] = {x = 5, y = 6} }
 16    entrypoint map_s() =
 17      { ["one"]   = {x = 1, y = 2},
 18        ["two"]   = {x = 3, y = 4},
 19        ["three"] = {x = 5, y = 6} }
 20    stateful entrypoint map_state_i() = put(state{ map_i = map_i() })
 21    stateful entrypoint map_state_s() = put(state{ map_s = map_s() })
 22  
 23    // m[k]
 24    entrypoint get_i(k, m : map(int,    pt)) = m[k]
 25    entrypoint get_s(k, m : map(string, pt)) = m[k]
 26    entrypoint get_state_i(k) = get_i(k, state.map_i)
 27    entrypoint get_state_s(k) = get_s(k, state.map_s)
 28  
 29    // m[k = v]
 30    entrypoint get_def_i(k, v, m : map(int,    pt)) = m[k = v]
 31    entrypoint get_def_s(k, v, m : map(string, pt)) = m[k = v]
 32    entrypoint get_def_state_i(k, v) = get_def_i(k, v, state.map_i)
 33    entrypoint get_def_state_s(k, v) = get_def_s(k, v, state.map_s)
 34  
 35    // m{[k] = v}
 36    entrypoint set_i(k, p, m : map(int,    pt)) = m{ [k] = p }
 37    entrypoint set_s(k, p, m : map(string, pt)) = m{ [k] = p }
 38    stateful entrypoint set_state_i(k, p) = put(state{ map_i = set_i(k, p, state.map_i) })
 39    stateful entrypoint set_state_s(k, p) = put(state{ map_s = set_s(k, p, state.map_s) })
 40  
 41    // m{f[k].x = v}
 42    entrypoint setx_i(k, x, m : map(int,    pt)) = m{ [k].x = x }
 43    entrypoint setx_s(k, x, m : map(string, pt)) = m{ [k].x = x }
 44    stateful entrypoint setx_state_i(k, x) = put(state{ map_i[k].x = x })
 45    stateful entrypoint setx_state_s(k, x) = put(state{ map_s[k].x = x })
 46  
 47    // m{[k] @ x = v }
 48    entrypoint addx_i(k, d, m : map(int,    pt)) = m{ [k].x @ x = x + d }
 49    entrypoint addx_s(k, d, m : map(string, pt)) = m{ [k].x @ x = x + d }
 50    stateful entrypoint addx_state_i(k, d) = put(state{ map_i[k].x @ x = x + d })
 51    stateful entrypoint addx_state_s(k, d) = put(state{ map_s[k].x @ x = x + d })
 52  
 53    // m{[k = def] @ x = v }
 54    entrypoint addx_def_i(k, v, d, m : map(int,    pt)) = m{ [k = v].x @ x = x + d }
 55    entrypoint addx_def_s(k, v, d, m : map(string, pt)) = m{ [k = v].x @ x = x + d }
 56  
 57    // Map.member
 58    entrypoint member_i(k, m : map(int,    pt)) = Map.member(k, m)
 59    entrypoint member_s(k, m : map(string, pt)) = Map.member(k, m)
 60    entrypoint member_state_i(k) = member_i(k, state.map_i)
 61    entrypoint member_state_s(k) = member_s(k, state.map_s)
 62  
 63    // Map.lookup
 64    entrypoint lookup_i(k, m : map(int,    pt)) = Map.lookup(k, m)
 65    entrypoint lookup_s(k, m : map(string, pt)) = Map.lookup(k, m)
 66    entrypoint lookup_state_i(k) = lookup_i(k, state.map_i)
 67    entrypoint lookup_state_s(k) = lookup_s(k, state.map_s)
 68  
 69    // Map.lookup_default
 70    entrypoint lookup_def_i(k, m : map(int,    pt), def : pt) =
 71      Map.lookup_default(k, m, def)
 72    entrypoint lookup_def_s(k, m : map(string, pt), def : pt) =
 73      Map.lookup_default(k, m, def)
 74    entrypoint lookup_def_state_i(k, def) = lookup_def_i(k, state.map_i, def)
 75    entrypoint lookup_def_state_s(k, def) = lookup_def_s(k, state.map_s, def)
 76  
 77    // Map.delete
 78    entrypoint delete_i(k, m : map(int,    pt)) = Map.delete(k, m)
 79    entrypoint delete_s(k, m : map(string, pt)) = Map.delete(k, m)
 80    stateful entrypoint delete_state_i(k) = put(state{ map_i = delete_i(k, state.map_i) })
 81    stateful entrypoint delete_state_s(k) = put(state{ map_s = delete_s(k, state.map_s) })
 82  
 83    // Map.size
 84    entrypoint size_i(m : map(int,    pt)) = Map.size(m)
 85    entrypoint size_s(m : map(string, pt)) = Map.size(m)
 86    entrypoint size_state_i() = size_i(state.map_i)
 87    entrypoint size_state_s() = size_s(state.map_s)
 88  
 89    // Map.to_list
 90    entrypoint tolist_i(m : map(int,    pt)) = Map.to_list(m)
 91    entrypoint tolist_s(m : map(string, pt)) = Map.to_list(m)
 92    entrypoint tolist_state_i() = tolist_i(state.map_i)
 93    entrypoint tolist_state_s() = tolist_s(state.map_s)
 94  
 95    // Map.from_list
 96    entrypoint fromlist_i(xs : list(int    * pt)) = Map.from_list(xs)
 97    entrypoint fromlist_s(xs : list(string * pt)) = Map.from_list(xs)
 98    stateful entrypoint fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
 99    stateful entrypoint fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })
100