You don’t say what we have at our disposal to solve the puzzle. If we are restricted to lambda definable functions there isn’t much to do. If we have something like por it’s a different matter.

augustss: I didn’t want to bias people’s explorations.

]]>`f ⊥ ≡ g ⊥`

is too strong. From Albert Lai’s explanation the minimal strictness is achieved when: `either f g ⊥ = f⊥ ⊓ g⊥`

. In Haskell:
```
either :: (HasLub c, HasGlb c) => (a -> c) -> (b -> c) -> Either a b -> c
either f g x = (f undefined) `glb` (g undefined) `lub` strictEither f g x
```

When `c`

is flat domain it is essentially David Sankel’s solution.

`lub`

instead of `unamb`

would make my version a bit lazier.
]]>```
either :: (Eq c, Lub c) ⇒ (a → c) → (b → c) → Either a b → c
either f g e = t1 `unamb` t2
where t1 = let a = f undefined
b = g undefined
in if a == b then (a `lub` b) else undefined
t2 = case e of Left a → f a
Right b → g b
```

]]>```
lazierEither (const True) (const False)
```

⇓

```
(const True . fromLeft) `lub` (const False . fromRight)
```

]]>