Difference between Generic parameter with a type constraint and just a regular type constraint

Playground.swift

import Foundation
import PlaygroundSupport

protocol SomeProtocol {
    var someProperty: Int { get }
}

// The parameter `some` is of type T and type T conforms to SomeProtocol
func generic<T: SomeProtocol>(some: T) -> Int {
    return some.someProperty
}

// The parameter `some` conforms to SomeProtocol
func nonGeneric(some: SomeProtocol) -> Int {
    return some.someProperty
}

struct Foo: SomeProtocol {
    var someProperty: Int
}

let foo: SomeProtocol = Foo(someProperty: 42)

// This doesn't compile because the `generic(some:)` expects a type T  which
// conforms to the protocol SomeProtocol. However, SomeProtocol does not conform
// to itself. generic(some: something)
generic(some: foo)

// This compiles because `foo` conforms to SomeProtocol
nonGeneric(some: foo)

Credit

What is the in-practice difference between generic and protocol-typed function parameters?