 
 enum location_t
 {
-  none = 1 << 0; 
-  
-  host = 1 << 1; 
+  none = 1 << 0;
+
+  host = 1 << 1;
   device = 1 << 2;
 
   all = 1 << 4;

      }
    }

    // pointers::
    CUDA_HOST_DEVICE constexpr pointer_t data(
      location_t target = location_t::default) noexcept
    {
      // Return pointer of array on host-side
      if (target == location_t::host)
        return const_cast<pointer_t>(h_pointer);

      // Default location is always device:
      return const_cast<pointer_t>(d_pointer);
    }

    CUDA_HOST_DEVICE constexpr const_pointer_t data(
      location_t target = location_t::default) noexcept
    {
      // Return const pointer of array on host-side
      if (target == location_t::host)
        return const_cast<const_pointer_t>(h_pointer);

      // Default location is always device:
      return const_cast<const_pointer_t>(d_pointer);
    }

    // capacity::
    CUDA_HOST_DEVICE constexpr _int_t size() const noexcept { return N; }
    CUDA_HOST_DEVICE constexpr bool empty() const noexcept
    {
      return (size() == 0);
    }

    // XXX
    resize(_int_t new_size) {}

    // XXX: deep copy
    copy() {}
    move() {}

    CUDA_HOST_DEVICE constexpr bool is_allocated(_int_t size,
                                                 location_t target) noexcept {
      // XXX: maybe needs an explicit memory check?
      return ((is_location_set(this->allocated, target)) && (size() == size))
    }

    CUDA_HOST_DEVICE __forceinline__ pointer
      pointer(location_t target = location_t::default) const
    {
      if (is_location_set(target, location_t::device))
        return d_pointer;

      if (is_location_set(target, location_t::host))
        return h_pointer;

      return std::nullptr;
    }

    // XXX: should this be CUDA_HOST_DEVICE?
    CUDA_HOST_DEVICE void set_pointer(type_t* p,
                     int_t size,
                     location_t target = location_t::default)
    {}

    // Scalar/Vector Operations

    // XXX: generalize using a lambda
    set() {}
    swap() {}
    fill() {}
    zero() {}

  } // struct: array
}

    type_t* h_pointer;
    type_t* d_pointer;

    location_t allocated;

    static constexpr reference_t reference(const reference_t p,
                                           size_t n) noexcept
    {
      return const_cast<reference_t>(p[n]);
    }

    __inline__ bool is_location_set(location_t targets, location_t check) const
    {
