Option<T>

T?

Option

None.toNullable()

Option.fromNullable(null)

@Serializer(forClass = Option::class)
class OptionSerializer<T : Any>(private val dataSerializer: KSerializer<T>) : KSerializer<Option<T>> {
    override val descriptor: SerialDescriptor = StringDescriptor.withName("OptionDescriptor")

    override fun deserialize(input: Decoder): Option<T> {
        return Option.fromNullable(input.decodeNullable(dataSerializer))
    }

    override fun serialize(output: Encoder, obj: Option<T>) {
        when (obj) {
            is None -> output.encodeNull()
            is Some -> output.encodeNullable(dataSerializer, obj.t)
        }
    }
}

@Serializable data class Stuff(@Serializable(with = OptionSerializer::class) val foo: Option<String>)

@Serializable

@Serializable(with = OptionSerializer::class)

@Test
    fun test() {
        val someStuff = Stuff(Some("haha"))
        val noneStuff = Stuff(None)
        val serializer = Stuff.serializer()

        val someStuffString = JSON.stringify(serializer, someStuff)
        val noneStuffString = JSON.stringify(serializer, noneStuff)

        println(someStuffString)
        println(noneStuffString)

        println(JSON.parse(serializer, someStuffString))
        println(JSON.parse(serializer, noneStuffString))
    }

{"foo":"haha"}
{"foo":null}
Stuff(foo=Some(haha))
Stuff(foo=None)

Store(uuid=uuid, name=name, ssid=None, connectivityTypes=[], location=Some(StoreLocation(address=Some(address), city=None, zipCode=None, latitude=None, longitude=None)))
{"uuid":"uuid","name":"name","ssid":null,"connectivityTypes":[],"location":{"address":"address","city":null,"zipCode":null,"latitude":null,"longitude":null}}

arrow-core-extensions

arrow.instances.option.monad.monad

Option

val foo = Option("hello")
val bar = Option("world")

fun concat(first: String, second: String): String {
   return "$first $second"
}

concat

foo

bar

Some(String)

val baz = Option.applicative().map("foo".some(), "bar".some(), {(a, b) -> concat(a, b)})

.fix()

::concat.tupled()

{ a, b -> concat(a, b)}

::concat

fun runMe(): Kind<ForOption, String> {
    return Option
        .applicative()
        .map(foo, bar) { (a, b) -> concat(a, b) }
}

concat(a, b)

.fix()