map.js

import {Typed, Type, Union, Any, typeOf, construct} from "./typed"
import * as Immutable from 'immutable'


const ImmutableMap = Immutable.Map
const {Keyed} = Immutable.Iterable

const $store = Typed.store
const $type = Typed.type
const $read = Typed.read
const $step = Typed.step
const $init = Typed.init
const $result = Typed.result
const $label = Typed.label
const $typeName = Typed.typeName
const $empty = Typed.empty

class EntryType extends Type {
  constructor(key, value, label) {
    super()
    this.key = key
    this.value = value
    this.label = label
  }
  [Typed.typeName]() {
    return this.label ||
           `${this.key[$typeName]()}, ${this.value[$typeName]()}`
  }
  [Typed.read]([key, value]) {
    const keyResult = this.key[$read](key)
    if (keyResult instanceof TypeError) {
      return TypeError(`Invalid key: ${keyResult.message}`)
    }

    const valueResult = this.value[$read](value)
    if (valueResult instanceof TypeError) {
      return TypeError(`Invalid value: ${valueResult.message}`)
    }

    return [keyResult, valueResult]
  }
}

class InferredEntryType extends EntryType {
  constructor() {
    super(key, value)
  }
  toStatic() {
    return new MapEntryType(this.key, this.value)
  }
  [Typed.typeName]() {
    const key = this.key ? this.key[$typeName]() : "TypeInferred"
    const value = this.value ? this.value[$typeName]() : "TypeInferred"
    return `${key}, ${value}`
  }
  [Typed.read](entry) {
    // typeOf usually creates type for the value with that
    // value being a default. For type inference we should
    // actually use a base type instead of type with default
    // there for we use prototype of the constructor.
    const key = typeOf(entry[0]).constructor.prototype
    this.key = this.key ? Union(this.key, key) : key

    const value = typeOf(entry[1]).constructor.prototype
    this.value = this.value ? Union(this.value, value) : value

    return entry
  }
}

const BaseImmutableMap = function() {}
BaseImmutableMap.prototype = Immutable.Map.prototype

class TypedMap extends BaseImmutableMap {
  constructor(value) {
    super()
    return TypedMap.prototype[$read](value)
  }
  advance(store) {
    const result = store.__ownerID ? this : construct(this)
    result[$store] = store
    result.size = store.size
    result.__ownerID = store.__ownerID
    return result
  }
  [Typed.init]() {
    return this.advance(ImmutableMap()).asMutable()
  }
  [Typed.step](state, entry) {
    const result = this[$type][$read](entry)

    if (result instanceof TypeError) {
      throw result
    }

    const [key, value] = result
    return state.advance(state[$store].set(key, value))
  }
  [Typed.result](state) {
    return state.asImmutable()
  }

  [Typed.read](structure) {
    const constructor = this.constructor

    if (structure === null || structure === void(0)) {
      if (!this[$empty]) {
        this[$empty] = this.advance(ImmutableMap())
      }

      return this[$empty]
    }

    const isInstance = structure instanceof constructor &&
                       structure.constructor === constructor

    if (isInstance) {
      return structure
    }


    const entries = Keyed(structure).entries()
    const type = this[$type]
    let state = this[$init]()

    while (true) {
      const {done, value: entry} = entries.next()

      if (done) {
        break
      }

      const result = type[$read](entry)

      if (result instanceof TypeError) {
        return result
      }

      state = state[$step](state, result)
    }

    return this[$result](state)
  }

  [Typed.typeName]() {
    return this[$label] || `Typed.Map(${this[$type][$typeName]()})`
  }

  toString() {
    return this.__toString(this[$typeName]() + '({', '})')
  }

  has(key) {
    return this[$store].has(key)
  }

  get(key, fallback) {
    return this[$store].get(key, fallback)
  }

  clear() {
    if (this.size === 0) {
      return this
    }

    if (this.__ownerID) {
      return this.advance(this[$store].clear())
    }

    return this[$empty] || this[$read]()
  }

  remove(key) {
    return this.advance(this[$store].remove(key))
  }

  set(key, value) {
    return this[$step](this, [key, value])
  }

  wasAltered() {
    return this[$store].wasAltered()
  }

  __ensureOwner(ownerID) {
    const result = this.__ownerID === ownerID ? this :
                   !ownerID ? this :
                   construct(this)

    const store = this[$store].__ensureOwner(ownerID)
    result[$store] = store
    result.size = store.size
    result.__ownerID = ownerID

    return result
  }
  __iterator(type, reverse) {
    return this[$store].__iterator(type, reverse)
  }

  __iterate(f, reverse) {
    return this[$store].__iterate(f, reverse)
  }
}
TypedMap.prototype[Typed.DELETE] = TypedMap.prototype.remove

class TypeInferredMap extends TypedMap {
  constructor() {
    super()
  }
  [Typed.init]() {
    const result = this.advance(ImmutableMap()).asMutable()
    result[$type] = new InferredEntryType()
    return result
  }
  [Typed.result](state) {
    const result = state.asImmutable()
    result[$type] = state[$type].toStatic()

    return result
  }
}

export const Map = function(keyDescriptor, valueDescriptor, label) {
  if (keyDescriptor === void(0)) {
    throw TypeError("Typed.Map must be passed a key type descriptor")
  }

  if (valueDescriptor === void(0)) {
    throw TypeError("Typed.Map must be passed a value type descriptor")
  }

  // If both key and value types are Any this is just a plain immutable map.
  if (keyDescriptor === Any && valueDescriptor === Any) {
    return ImmutableMap
  }

  const keyType = typeOf(keyDescriptor)
  const valueType = typeOf(valueDescriptor)

  if (keyType === Any && keyDescriptor !== Any) {
    throw TypeError(`Typed.Map was passed an invalid key type descriptor: ${keyDescriptor}`)
  }

  if (valueType === Any && valueDescriptor !== Any) {
    throw TypeError(`Typed.Map was passed an invalid value type descriptor: ${valueDescriptor}`)
  }

  const type = new EntryType(keyType, valueType, label)

  const MapType = function(value) {
    const isMapType = this instanceof MapType
    const constructor = isMapType ? this.constructor : MapType

    if (value instanceof constructor) {
      return value
    }

    const result = constructor.prototype[$read](value)

    if (result instanceof TypeError) {
      throw result
    }

    if (isMapType && !this[$store]) {
      this[$store] = result[$store]
      this.size = result.size
    } else {
      return result
    }

    return this
  }
  
  MapType.of = (...keyValues) => {
    return MapType().withMutations(map => {
      for (var i = 0; i < keyValues.length; i += 2) {
        if (i + 1 >= keyValues.length) {
          throw new Error('Missing value for key: ' + keyValues[i]);
        }
        map.set(keyValues[i], keyValues[i + 1]);
      }
    });
  }

  MapType.prototype = Object.create(MapPrototype, {
    constructor: {value: MapType},
    [$type]: {value: type},
    [$label]: {value: label}
  })

  return MapType
}
Map.Type = TypedMap
Map.prototype = TypedMap.prototype
const MapPrototype = Map.prototype