I wrote a function that accepts input ranges, and I get compile errors when passing an array

[pineapple via Digitalmars-d-learn]

I'm writing my own map function modeled after the one in phobos. 
(because I feel like it, that's why. good learning experience.) 
I've encountered one remarkable difference: The phobos function 
accepts arrays and mine does not. I understand why - I'm calling 
methods that arrays don't have - but what I don't understand is 
why the phobos function _does_ work. I haven't been able to find 
what in the phobos code accounts for iterables that aren't ranges.

What am I missing?


     enum canMap(T) = isInputRange!(Unqual!T);

     auto map(alias func, Range)(Range range) if(canMap!Range){
         return Mapping!(func, Range)(range);
     }

     struct Mapping(alias func, Range) if(canMap!Range){

         alias URange = Unqual!Range;
         Range input;

         this(URange input){
             this.input = input;
         }

         void popFront(){
             this.input.popFront();
         }
         @property auto ref front(){
             return func(this.input.front);
         }

         static if(isBidirectionalRange!URange){
             @property auto ref back(){
                 return func(this.input.back);
             }
             void popBack(){
                 this.input.popBack();
             }
         }

         static if(isInfinite!URange){
             enum bool empty = false;
         }else{
             @property bool empty(){
                 return this.input.empty;
             }
         }

         static if(isRandomAccessRange!URange){
             static if(is(typeof(URange.opIndex) == function)){
                 alias Index = Parameters!(URange.opIndex)[0];
             }else{
                 alias Index = size_t;
             }
             auto ref opIndex(Index index){
                 return func(this.input[index]);
             }
         }

         static if(is(typeof(URange.opDollar))){
             alias opDollar = URange.opDollar;
         }

         static if(hasLength!URange){
             @property auto length(){
                 return this.input.length;
             }
         }

         static if(hasSlicing!URange){
             static if(is(typeof(URange.opIndex) == function)){
                 alias SliceIndex = Parameters!(URange.opIndex)[0];
             }else{
                 alias SliceIndex = size_t;
             }
             auto opSlice(SliceIndex low, SliceIndex high){
                 return typeof(this)(this.input[low .. high]);
             }
         }

         static if(isForwardRange!URange){
             @property auto save(){
                 return typeof(this)(this.input.save);
             }
         }

     }

     version(unittest) import mach.error.unit;
     unittest{
         import std.stdio;
         //import std.algorithm : map; // Works with this

         // no property 'popFront', etc for type 'int[]'
         writeln(
             [1, 2, 3].map!((item) => (item * item))
         );
     }

Tangentially related question - Why does phobos use 
isInputRange!(Unqual!T) instead of just isInputRange!T? What's 
the functional difference here?