but I'm struggling to come up with a real-life exa...

# arrow

[Bob Glamm]

but I'm struggling to come up with a real-life example for how to swap out instances of <F> in something like the following:

interface S3Ops<F>: MonadDefer<F> {

    val s3: AmazonS3

    fun getS3Info(bucket: String, key: String): Kind<F, S3Object> {

        val waiterRequest = GetObjectMetadataRequest(bucket, key)

        return catch { s3.waiters().objectExists().run(WaiterParameters(waiterRequest)) }
                .flatMap {
                    val objectRequest = GetObjectRequest(bucket, key)
                    catch { s3.getObject(objectRequest) }
                }.flatMap {
                    if (it == null) {
                        raiseError(RuntimeException("No object retrieved from S3"))
                    } else {
                        just(it)
                    }
                }
    }

[pakoito]

object IOBla: S3Ops<F>, MonadDefer<F> by IO.monadDefer() {
  override val s3: AmazonS3 = s3()
}

[pakoito]

object RxBla: S3Ops<F>, MonadDefer<F> by Observable.monadDefer() {
 override val s3: AmazonS3 = s3()
}

[pakoito]

you can apply part of an interface using delegation

[pakoito]

and the other with overrides

[Bob Glamm]

Agree, changing effect semantics or interfacing makes sense. The context in consideration in the linked paper changes the entire behavior (expression evaluation vs. expression pretty-printing)

[Bob Glamm]

and that's where I'm struggling - maybe it's not possible to "pretty-print" functions specified as arguments to catch/flatMap above

[pakoito]

ooooooh

[pakoito]

full program reification?

[pakoito]

look into Free Monad

[Bob Glamm]

I think my disconnect right now is assuming that I can apply arbitrary algebras to any type

[Bob Glamm]

e.g. it's easy to provide printers or evaluators for Exprs but not so much for S3Ops

[Bob Glamm]

Would it be fair to say that the algebras in Arrow are the algebras of effects, vs. the generalized algebras suggested in the paper?

[Bob Glamm]

yeah, that must be the case since the algebra is constrained - in the above example F has to be MonadDefer instead of the general F in the paper

[Bob Glamm]

Thanks for the discussion 🙂

[pakoito]

Yes, in the case of Free Monad an algebra resembles something like an event bus, or a reducer if you prefer those terms

[pakoito]

you define your program as a reification of execution

[pakoito]

and your subscriber/reducer takes that algebra of messages and interprets it to a value

[pakoito]

Ank is written like that

[pakoito]

or at least it used to

[Bob Glamm]

Free Monads/free algebras are probably the next step on my journey to enlightenment, TBH

[pakoito]

https://github.com/arrow-kt/ank/blob/master/ank-core/src/main/kotlin/arrow/ank/algebra.kt

[pakoito]

https://github.com/arrow-kt/ank/blob/master/ank-core/src/main/kotlin/arrow/ank/interpreter.kt#L38-L45

[pakoito]

if you squint it’s a reducer except that reducer is applicative (1 message, 1 effect) and this is monadic (1 message, N effects)

[Bob Glamm]

I'll need to spend some time squinting at it. Thanks for the pointer!

[pakoito]

👍🏼

[Bob Glamm]

Thanks for the pointer. I think I got it while I was falling asleep last night - I just need to create a base language that describes operations (rather than performs them) then create the interpreters that act on the operations I can achieve both "pretty-printing" and actual S3 operations.

[pakoito]

yes

[pakoito]

the design is as follows:

[pakoito]

myOperationFunction(parameter: String): User

[pakoito]

becomes

[pakoito]

data class MyOperationData(val parameter: String): MyAlgebra<F, User>

[pakoito]

and MyAlgebra is the composition of all operations, parametrized to F

[pakoito]

actually it may not even be necessary

[pakoito]

just MyAlgebra<User> and that flattens for `F`in the interpeter

[Bob Glamm]

Yup. I'm not quite to that level of abstraction yet but I have enough in front of me to see that I can replace mocking with interpreters that (e.g.) parameterize over State<S,A> and record the list of operations to be executed instead of mocking, which is quite nice