Hi all, I have a general question about structurin...

# arrow

[tim]

Hi all, I have a general question about structuring my app/State when trying to be more functional. At its core, I have a data class that represents state and I'm using a redux like setup. So when a request comes in, I follow this pattern:

data class State(val foo: Int = 1)
typealias NextState = State

// ...
val action = Action.Ping()
val next: NextState = state
  .dispatch(action)
  .save()

// Now maybe i'll grab a value off of next to send back to the user if that makes sense in the current context
//...

So this approach works fine, but I'm finding an increasing number of use cases where I want to return NextState and a Result. And I'd appreciate any feedback on what others think is a good way to handle this or a call out if my approach is bonkers ... still new to FP 🙂

I'm considering two approaches to achieve the above:
• fun <T> dispatch(action: Action): Either<Failure, Tuple2<NextState, T>>
• fun dispatch(action: Action): Either<Failure, NextState> In this approach I modify State to have non-serialised var that holds the return value: data class State(val foo: Int = 1, var result: Option<Any> = None) { fun <T> getResult(): Option<T> }
Is there a better way of doing this, is there a preferred approach, is this sound? Any thoughts welcome.

[PHaroZ]

have you taken a look to https://arrow-kt.io/docs/arrow/mtl/state/ ?

[tim]

I did when i started my FP journey + Arrow a few months back but it went right over my head then 🙂

[tim]

Does it solve this type of problem? Edit: ah yes I can see just from the intro it does exactly this 😂

[PHaroZ]

you will find an example of use here : https://www.47deg.com/blog/conway-kotlin/

[PHaroZ]

I haven't tried it by my own but it sounds very interesting :)

[tim]

brilliant i'll take a detailed look

[tim]

any thoughts on the redux flow?

[tim]

i don't see it mentioned very often in the kotlin world, but i do quite like it

[PHaroZ]

I started to dev with kotlin 4 months ago, I wouln'd pretend to juge your flow. 🙂

[tim]

I started with Kotlin 7 months ago .. so the blind leading the blind? 😂

[PHaroZ]

anyway working this with a State object seems a valid FP approch. On the other hand I would not rely on State methods to compute a next state, I would prefer some utily classes, one per action type

[PHaroZ]

something as UseCases in CLEAN architecture (https://proandroiddev.com/kotlin-clean-architecture-1ad42fcd97fa)

[tim]

i follow something pretty close to that: https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/

[tim]

mostly inspired by that

[tim]

Within the redux flow, state modifications are done by reducers/slices where each reducer/slice is responsible for updating different elements of state

[tim]

so basically each action is handled by a specific reducer

[Scott Christopher]

The Redux flow is effectively a Moore Machine (a specialised representation of a finite state machine), which Arrow actually already has a data type for: https://arrow-kt.io/docs/arrow/ui/moore/index.html

[Scott Christopher]

Which essentially amounts to:

data class Moore<Input, State>(val state: State, val handler: (Input) -> State)

[Scott Christopher]

This implies the handlers are free from effects though.

[Scott Christopher]

There is also a Mealy Machine, which allows for effects though I don't believe there is a representation of it in Arrow.

[tim]

Oh thats very interesting i'll have to check it out

[tim]

thanks for pointing it out