Discord is now Scala’s main chat platform. Please join us at https://discord.com/invite/scala
for example, "get an Int, then apply the transformation that increments that Int, then apply the transformation that transforms that Int to a String"
we're going to look at the shape of it first, and then the implementation
so, recall that in
State[S, A], A is the output
so "get an Int" will have type
"increment that Int" will have type
"transform that Int to String" will have type
get: State[Int, Int]"increment that Int" will have type
State[Int, Int] (the first Int is the state, and stays as it is, the second state is the result, and gets incremented)"transform that Int to String" will have type
State[Int, String] (the state is an Int, the result is now String)
makes sense?
it is
map yeah :)
but before
State you don't really look at it as "transforming the output of a program"
can you also write the signature of
map? (don't worry about making it infix)
get[Int].map(_ + 1).map(_.toString) is describing the sequence of transformations (that I described above) over an Int , that we will pass eventually, in run
that's why I ask at which point you are (behind, at, or beyond)
and let me know if you get stuck
I.e. show the input state as well
the real one will look like yours because it's inside
State to allow to be called infix
but yeah basically they are equivalent
so now we need to implement it
I understood it already actually.
but when I write example I cheat and write
get[Int].map.. etc
scala 3 will have infix functions and solve this annoying pedagogical trap
anyway, sounds like you understood the signature, and understood how to use it as well
yes
anyway, we just need to implement it now
we will try to follow type driven programming
it's a bit verbose in chat, but I'll try
also if a moderator prefers this convo to be moved to DM, please let me know (Seth basically)
ok so
def map[A, B]: State[S, A] => (A => B) => State[S, B]
we always start from the end, i.e.
State[S, B]