i'd imagine it'd be better if `fizz` returned nullable, then ```foo.fizz()?.log()```

# announcements

[Hullaballoonatic]

i'd imagine it'd be better if fizz returned nullable, then

foo.fizz()?.log()

[william]

i don't have control over this api but maybe i can use an extension method to help me achieve that

[Hullaballoonatic]

yeah, that's what I often do

[Toddobryan]

What if it's not an error? Does it just have a side effect or does it return a value?

[william]

there are side effects, only the result is returned (error type)

[Hullaballoonatic]

I assume it's a java library or something, and it's an error getter or something

[william]

no its not an error getter these are methods called for their side effects but an error type is returned

[Hullaballoonatic]

so i'd personally write an extension property:

val Foo.error get() = foo.fizz().let { if (it.isNotNone()) it else null }

or something

oh, alright. well, idk. examples.

[Toddobryan]

You could do something like a handle function that puts all the error handling in one place. Then it's just

handle(foo.fizz())
handle(foo.buzz())
...

[Toddobryan]

Or an extension on the error types and

foo.fizz().handle()
foo.buzz().handle()

[william]

thats what i've done ^

[william]

thinking about something like this too but not practical unless i can make them each lazy

handle(
    foo.fizz(),
    foo.buzz()
)
...

    private fun handle(vararg operations: Error) {
        operations.forEach { op ->
            if (op != Error.NONE ) {
                // ...
            }
        }
    }

[Toddobryan]

Yeah. You could do a block there to solve the lazy issue, but you'd still have to wrap each call in some kind of function to check the result.

[william]

@Toddobryan how would a block help me here? i'm not seeing how i could use that to wrap each call individually

[Toddobryan]

No, you can't. That's what I meant.

[william]

ah ok. well i definately don't need to do anything fancy like that, just thought it would be cool if i could

[Toddobryan]

someFun {
   foo.fizz()
   foo.buzz()
   ...
}

means the functions don't need to be lazy and lets you exit early on a severe-enough error, but doesn't help at all with the fact that you'd still have to handle each error individually somehow. 😞

[william]

yeah exactly thats what i couldnt figure

[william]

oh well 🤷