Return specific property when accessing a Struct without referencing its name

It's possible by adopting CustomStringConvertible and constraining T also to CustomStringConvertible

public struct ASValue<T: Hashable>: Hashable, CustomStringConvertible where T: CustomStringConvertible {
    
    private let id = UUID()
    public var item: T
    
    public var description : String {
        return "\(item)"
    }
}

let val = ASValue(item: "Example")

print(val) // Prints: Example

And this is a struct, the init method is for free.

What you are looking for is exactly provided with property wrappers in swift. You have to make your ASValue structproperty wrapper by applying @propertyWrapper to the declaration:

@propertyWrapper
public struct ASValue<T: Hashable>: Hashable {
    private let id = UUID()
    public var wrappedValue: T

    public init(wrappedValue: T) {
        self.wrappedValue = wrappedValue
    }
}

Then you can use this wrapper to wrap any property in another type and access that property directly. You can even access the ASValue wrapper type by prefixing with _:

class SomeClass {
    @ASValue var val = "Example"

    func printVal() {
        // print(_val) for actual value
        print(val) // Prints: Example
    }
}

You can also pass this property with its wrapper identity to other function:

func printVal<T: Hashable>(@ASValue val: T) {
    // print(_val) for actual value
    print(val) // Prints: Example
}

let obj = SomeClass()
printVal(val: obj.val)

If for some constraint you can't use the property wrapper approach you can try the @dynamicCallable attribute as a workaround. This allows values created from your types to be invoked as methods with specified arguments.

@dynamicCallable
public struct ASValue<T: Hashable>: Hashable {
    private let id = UUID()
    public var item: T

    public init(item: T) {
        self.item = item
    }

    // need to have withArguments with argument type confirming
    // to ExpressibleByArrayLiteral
    func dynamicallyCall(withArguments arg: [Int] = []) -> T {
        return item
    }
}

let val = ASValue(item: "Example")
print(val()) // Prints: Example