If you remove the array subexpression @(...) and just precede with a comma. The below code seems to work:

Copyfunction TestReturn {
    $returnList = New-Object System.Collections.Generic.List[string]
    $returnList.Add('Testing, one, two')

    return , $returnList
}

$testList = TestReturn
$testList.GetType().FullName

Note: technically this causes the return of [Object[]] with a single element that's of type [System.Collections.Generic.List[string]]. But again because of the implicit unrolling it sort of tricks PowerShell into typing as desired.

On your later point, the syntax [Type]$Var type constrains the variable. It's basically locking in the type for that variable. As such subsequent calls to .GetType() will return that type.

These issues are due to how PowerShell implicitly unrolls arrays on output. The typical solution, somewhat depending on the typing, is to precede the return with a , or ensure the array on the call side, either by type constraining the variable as shown in your questions, or wrapping or casting the return itself. The latter might look something like:

Copy$testList = [System.Collections.Generic.List[string]]TestReturn
$testList.GetType().FullName

To ensure an array when a scalar return is possible and assuming you haven't preceded the return statement with , , you can use the array subexpression on the call side:

Copy$testList = @( TestReturn )
$testList.GetType().FullName

I believe this answer deals with a similar issue

I was not able to reproduce the situation you described.

$foo=[system.collections.generic.list[string]]::new()
$foo.Add("A")
$foo.Add("B")
$foo.Add("C")
[string[]]$bar=$foo.ToArray()
$bar.GetType().FullName

"System.String[]"

You need a For-Each Loop like follows:, but with your parameters in it:

Get-ADComputer -Filter {Enabled -eq "true"} -Searchbase " OU=DISABLED,OU=COMPUTERS, OUs,DC=STORE,DC=NETWORK" -Properties * | ?{($_.LastLogonDate -lt (Get-Date).AddDays(-120)) -and ($_.LastLogonDate -ne $NULL)} | Select Name | Out-File C:\users\user\Desktop\DisabledPcs.csv

$computers = gc C:\users\user\Desktop\disabledpcs.csv
ForEach ($computer in $computers){
  get-adcomputer $computer | Move-ADObject -TargetPath "OU=DISABLED,OU=COMPUTERS, OUs,DC=STORE,DC=NETWORK"
}
Write-Host "Disabled Pcs moved to Disabled OU" -ForegroundColor Green

I think Group-Object (alias: group) is the perative cmdlet for this task.

Here's one way:

$SourceList = @('PONTEVEDRA:false','MADRID:true','MADRID:true','PONTEVEDRA:true')
$NewList = $SourceList | ForEach{
    $_ -match '(.+):(.+)' | out-null
    [PSCustomObject]@{
        'Loc' = $matches[1]
        'Bool'= $matches[2]
    }
} | Group Loc -pv loc | ForEach{
    $BoolSplit = $_.Group | Group Bool -NoElement
    '{0}:{1}:{2}' -f $loc.Name,
                     ($BoolSplit | ? Name -eq 'True').Count,
                     ($BoolSplit | ? Name -eq 'False').Count
}

$NewList

Edit: Including summary information

If you break down the above code to see what's in the pipeline, you'll see that this code segment:

$SourceList | ForEach{
    $_ -match '(.+):(.+)' | out-null
    [PSCustomObject]@{
        'Loc' = $matches[1]
        'Bool'= $matches[2]
    }
}

Creates these objects:

Loc        Bool
---        ----
PONTEVEDRA false
MADRID     true
MADRID     true
PONTEVEDRA true

which, if grouped by Bool, will get the total counts of "True" and "False":

PS > $SourceList | ForEach{
>>     $_ -match '(.+):(.+)' | out-null
>>     [PSCustomObject]@{
>>         'Loc' = $matches[1]
>>         'Bool'= $matches[2]
>>     }
>> } | Group Bool

Count Name                      Group
----- ----                      -----
    1 false                     {@{Loc=PONTEVEDRA; Bool=false}}
    3 true                      {@{Loc=MADRID; Bool=true}, @{Loc=MADRID; Bool=true}, ...

So to capture the intermediate object, modify the original code to create another collection. This segment:

$NewList = $SourceList | ForEach{
    $_ -match '(.+):(.+)' | out-null
    [PSCustomObject]@{
        'Loc' = $matches[1]
        'Bool'= $matches[2]
    }
}

becomes this:

$NewList = ( $SumList = $SourceList | ForEach{
    $_ -match '(.+):(.+)' | out-null
    [PSCustomObject]@{
        'Loc' = $matches[1]
        'Bool'= $matches[2]
    }
} )

Then, when you run the modified code, you've not only created $NewList, but $SumList as well. With that, you group and select:

PS > $sumList | Group Bool -NoElement | select Name, Count

Name  Count
----  -----
false     1
true      3

So, the full modified code would be:

$SourceList = @('PONTEVEDRA:false','MADRID:true','MADRID:true','PONTEVEDRA:true')
$NewList = ( $SumList = $SourceList | ForEach{
    $_ -match '(.+):(.+)' | out-null
    [PSCustomObject]@{
        'Loc' = $matches[1]
        'Bool'= $matches[2]
    }
} ) | Group Loc -pv loc | ForEach{
    $BoolSplit = $_.Group | Group Bool -NoElement
    '{0}:{1}:{2}' -f $loc.Name,
                     ($BoolSplit | ? Name -eq 'True').Count,
                     ($BoolSplit | ? Name -eq 'False').Count
}

$NewList

$sumList | Group Bool -NoElement | select Name, Count

Edit3: Alternate summary method:

While the above would be good if you needed further access to your original data in object form, but if all you need are the sums mentioned, the following would probably more effecient and faster. It doesn't create another collection or list, but rather uses to refernce variables to keep a running total as the data is processed:

$SourceList = @('PONTEVEDRA:false','MADRID:true','MADRID:true','PONTEVEDRA:true')

[ref]$TrueTotal  = 0
[ref]$FalseTotal = 0

$NewList = $SourceList | ForEach{
    $_ -match '(.+):(.+)' | out-null
    [PSCustomObject]@{
        'Loc' = $matches[1]
        'Bool'= $matches[2]
    }
} | Group Loc -pv loc | ForEach{
    $BoolSplit = $_.Group | Group Bool -NoElement
    '{0}:{1}:{2}' -f $loc.Name,
                     ($TrueCount  = ($BoolSplit | ? Name -eq 'True').Count),
                     ($FalseCount = ($BoolSplit | ? Name -eq 'False').Count)
    $TrueTotal.Value  += $TrueCount
    $FalseTotal.Value += $FalseCount
}

$NewList
'Total "True"  : {0}' -f $TrueTotal.Value
'Total "False" : {0}' -f $FalseTotal.Value`

Edit #2: Additional data

Same as before, the first thing you want to do is convert your data into objects. I took a slightly different tack this time -- not to confuse, but to show an alternate method. If your data is actually coming from a file, you would use Import-Csv rather than ConvertFrom-Csv:

$list = @('PONTEVEDRA:false:siAPP','MADRID:true:noAPP','MADRID:true:noAPP','PONTEVEDRA:true:siAPP')

$ListObjects = $List | ConvertFrom-Csv -Delimiter ':' -Header ('Loc','locBool','AppInfo')

Which yields:

PS > $ListObjects

Loc        locBool AppInfo
---        ------- -------
PONTEVEDRA false   siAPP
MADRID     true    noAPP
MADRID     true    noAPP
PONTEVEDRA true    siAPP

And again, group on **Loc** :

PS > $ListObjects | group Loc

Count Name                      Group
----- ----                      -----
    2 PONTEVEDRA                {@{Loc=PONTEVEDRA; locBool=false; AppInfo=siAPP; Count=2; Na...
    2 MADRID                    {@{Loc=MADRID; locBool=true; AppInfo=noAPP; Count=2; Name=MA...

And with the Group property of each of those, we can extract the data you want using the Where method available to collections:

$ListObjects | Group Loc | %{
    $BoolGroup = $_.Group | Group locBool -NoElement
    $AppGroup  = $_.Group | Group AppInfo -NoElement
    '{0}:{1}:{2}:{3}:{4}' -f $_.Name ,
                             $BoolGroup.Where{$_.Name -match 'true'}[0].Count ,
                             $BoolGroup.Where{$_.Name -match 'false'}[0].Count ,
                             $AppGroup.Where{$_.Name -match 'siAPP'}[0].Count ,
                             $AppGroup.Where{$_.Name -match 'noApp'}[0].Count
}

Output:

PS > $ListObjects | Group Loc | %{
>>     $BoolGroup = $_.Group | Group locBool -NoElement
>>     $AppGroup  = $_.Group | Group AppInfo -NoElement
>>     '{0}:{1}:{2}:{3}:{4}' -f $_.Name ,
>>                              $BoolGroup.Where{$_.Name -match 'true'}[0].Count ,
>>                              $BoolGroup.Where{$_.Name -match 'false'}[0].Count ,
>>                              $AppGroup.Where{$_.Name -match 'siAPP'}[0].Count ,
>>                              $AppGroup.Where{$_.Name -match 'noApp'}[0].Count
>> }
>>
PONTEVEDRA:1:1:2:0
MADRID:2:0:0:2
PS >

Note that becaue the Where() method returns a collection even when there is zero or one element -- and because collections have a Count property of their own, you have to specify the [0] array index to get the Count from the BoolGroup and AppGroup sub-groups. Without that, Count would only return 0 or 1 -- depending on whether or not therewere any elements in the specified grouping.