As mentioned in the comments at the beginning of part 4, that type should really be something like forall a. Bool a, but it's not possible to encode that type there, and lambda calculus Booleans require a more expressive system then STLC (e.g System F) to encode.

So you just need to write something that's semantically correct, which then you can either remove that type annotation, or change it to something that matches your correct type.

Incidentally, you can even write not' with a type of SKI (Bool' (Bool' a) -> Bool' a) instead of SKI (Bool' a -> Bool' a) and get a lambda term that's completely correct.

Fixed ;-)

I hope you mean 'semantically correct' ...

This comment is hidden because it contains spoiler information about the solution

Well, I did told you to reuse the combinators to prevent expanding into SK hell ;-)

Oh god, how I missed how the boolean logic should work :/

As mentioned in the comments at the beginning of part 4, that type should really be something like

`forall a. Bool a`

, but it's not possible to encode that type there, and lambda calculus Booleans require a more expressive system then STLC (e.g System F) to encode.So you just need to write something that's semantically correct, which then you can either remove that type annotation, or change it to something that matches your correct type.

Incidentally, you can even write

`not'`

with a type of`SKI (Bool' (Bool' a) -> Bool' a)`

instead of`SKI (Bool' a -> Bool' a)`

and get a lambda term that's completely correct.It would be nice to have a test on these, the other functions are straightforward if you know their haskelly equivalents.

I do not understand the type of these functions:

Why isn't it:

?

I guess closed?

Thanks, I just fixed this!

Sample tests are still not fixed with the

`property (\l -> myFoldr (&&) True l == and (l :: [Bool]))`

line.(I'll do this myself once I solve this kata, leaving this for now as a reminder to myself)

Ah! Makes more sense, will try that!

The comparison is done

recursively.A more appropriate wording would be

`select the one with the largest width of the first element of the array in which they differ`

:)I did see your comment and follow it. However, there are cases where the following are both valid solutions:

In that case, both solutions are valid, and both have the same width for the "first" element.

Did you also follow the order in which the pieces should be cut and ordered?

See the question I raised below :)

## Loading more items...