"Skip does not support the referenced type as a generic constraint"

[dfabulich]

I'm hard at work on porting https://github.com/ukushu/Ifrit to Skip Lite, and I've hit a roadblock.

https://github.com/ukushu/Ifrit/blob/eb43c0690c969f080dacc0478eeecc1482ee6e0c/Sources/Ifrit/Classes/Fuse%2B/Fuse%2BFuseProps.swift#L11

public func searchSync<S: Sequence>(_ text: String, in aList: S) -> [FuzzySrchResult] where S.Element == [FuseProp] {

When I try to transpile that code, I get an error:

Skip does not support the referenced type as a generic constraint

Reading the documentation, I think that error message is supposed to be fixable with a SKIP DECLARE comment, like this:

// SKIP DECLARE: open fun searchSync(text: String, in_: Sequence<Array<FuseProp>>): Array<FuzzySrchResult>
public func searchSync<S: Sequence>(_ text: String, in aList: S) -> [FuzzySrchResult] where S.Element == [FuseProp] {

But that doesn't work, because SKIP DECLARE doesn't work.

• Complex generic constraints can't be overridden with SKIP DECLARE #432

You can repro the issue on the restore-sequences branch of https://github.com/dfabulich/skip-ifrit/tree/restore-sequences

A simple swift build will repro the problem.

How do I fix this?

[marcprux]

What happens if you try to simplify the declaration to just use an Array? Like:

public func searchSync(_ text: String, in aList: [[FuseProp]]) -> [FuzzySrchResult]

There might be a way to get the Sequence generic working, but I want to first see if the simplified form works.

[dfabulich]

That works fine; it's what I'm doing on the main branch.

https://github.com/dfabulich/skip-ifrit/blob/e173d5e229ad0708c75e0e7d58b99810cda98326/Sources/SkipIfrit/Classes/Fuse%2B/Fuse%2BFuseProps.swift#L11

public func searchSync(_ text: String, in aList: [[FuseProp]]) -> [FuzzySrchResult] {

But that breaks backwards compatibility and prevents the user from passing in a lazy sequence. (skip-lib doesn't support those either, but that's a separate matter.)

[marcprux]

Note that SKIP DECLARE: does work, but the problem is that Skip is short-circuiting before it is even evaluated because it sees its limitation on the generic constraint. We don't parse the contents of SKIP DECLARE, so we don't see that it is overcoming the generic constraint limitations by redefining the type parameter.

One way to work around this could be to externalize that constraint as a conditional typealias. Something like:

#if !SKIP
typealias SequenceOfStrings<S> = S where S: Sequence, S.Element == [String]
#else
typealias SequenceOfStrings = Sequence<Array<String>>
#endif

public func searchSync<S>(_ text: String, in aList: SequenceOfStrings<S>) -> [FuzzySrchResult] {
}

That way you won't need to use a SKIP DECLARE: at all.

[dfabulich]

I did have to use SKIP DECLARE, but a conditional typealias made it work.

#if !SKIP
public typealias SequenceOfArraysOfFuseProps<S> = S where S: Sequence, S.Element == [FuseProp]
#else
public typealias SequenceOfArraysOfFuseProps = Sequence<Array<FuseProp>>
#endif

// SKIP DECLARE: open fun searchSync(text: String, in_: Sequence<Array<FuseProp>>): Array<FuzzySrchResult>
public func searchSync<S: Sequence>(_ text: String, in aList: SequenceOfArraysOfFuseProps<S>) -> [FuzzySrchResult] {