Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Activity
  • Oct 16 23:34
    SethTisue edited #12171
  • Oct 16 23:34
    SethTisue unlabeled #10603
  • Oct 16 23:33
    SethTisue demilestoned #10603
  • Oct 16 23:33
    SethTisue closed #10603
  • Oct 16 23:33
    SethTisue commented #10603
  • Oct 15 19:04
    NthPortal review_requested #9786
  • Oct 15 17:20
    Kordyjan commented #1284
  • Oct 15 17:14
    Kordyjan synchronize #1284
  • Oct 15 17:13
    Kordyjan opened #1284
  • Oct 15 16:31
    som-snytt commented #12473
  • Oct 15 15:22
    NthPortal commented #12473
  • Oct 15 15:18
    NthPortal commented #12473
  • Oct 15 15:16
    NthPortal commented #12473
  • Oct 15 15:15
    NthPortal commented #12473
  • Oct 15 15:11
    NthPortal commented #12473
  • Oct 15 14:49
    ches commented #12378
  • Oct 15 13:15
    bishabosha edited #2205
  • Oct 15 13:15
    bishabosha assigned #2205
  • Oct 15 13:14
    bishabosha review_requested #2205
  • Oct 15 13:14
    bishabosha review_requested #2205
Fabio Labella
@SystemFw

but where is the definition of run where it takes the S and

so you have various State computations, right?

which you can combine together with map and flatMap and pure etc
Renan Reis
@renanreismartins
yes
Fabio Labella
@SystemFw
so, those computations are building the function
so what's the starting point?
the initial mini functions that get combined together
those are the primitive State computation, i.e get and put

I think this view is confusing

so actually I take this back

you can build a State computation by passing the function
and that's how get and put are built
Renan Reis
@renanreismartins
@SystemFw yes, the example from the book is quite complex, at least for me, the way he creates that function, so Im trying to decompose
Fabio Labella
@SystemFw
or, you can build State computations based on other State computations
ok, so what State represents is a sequence of transformations over an S
Renan Reis
@renanreismartins

Do you guys have a simple example?

The way the book creates the computation:

def simulateMachine(inputs: List[Input]): State[Machine, (Int, Int)] = for {
    _ <- sequence(inputs map (modify[Machine] _ compose update))
    s <- get
  } yield (s.coins, s.candies)
Fabio Labella
@SystemFw
which will result in an A
that's what State[S, A] means, "a sequence of transformation over an S, which will result in an A"
does this bit make sense?
I will get to simple examples soon, once the main concepts are clarified :)
Renan Reis
@renanreismartins

that's what State[S, A] means, "a sequence of transformation over an S, which will result in an A"

yes

Fabio Labella
@SystemFw
ok, so once you have built this sequence of transformations, you pass the initial state, and you get back the result A (and the final new state, which is also of type S)
does this also make sense?
this is what you do when you write mySequenceOfTransformationsWhichIsStateSA.run(initialState)
Renan Reis
@renanreismartins
Also does, looks like very much with Random number Generator, previously on the chapter. Till here i can follow you

this is what you do when you write mySequenceOfTransformationsWhichIsStateSA.run(initialState)

perfect :)

Luis Miguel Mejía Suárez
@BalmungSan
@renanreismartins btw, even if I know Fabio will be able to make it clear (because he always does). May I ask, what was your experience with Scala before that book?
It is quite complex and some people recommend learning the language + fp with it which IMHO it is really an overkill.
Fabio Labella
@SystemFw
right, so we can start by building the simplest State program, the program whose final result is the state itself
the name of this program is get, and its type is State[S, S], i.e. the sequence of transformations on S which will return S itself (which is what "getting the state" is)
fair enough?
Renan Reis
@renanreismartins

@BalmungSan I read:
Programming Scala - martin

did the coursera and...

https://alvinalexander.com/scala/functional-programming-simplified-book/

https://www.amazon.com/Functional-Programming-Java-functional-techniques/dp/1617292737 - this is very similar to the scala book, but in java and not sooooo deep, more into data structures than category theory / monads.

I had no problem in the Functional Scala till this chapter :/

Fabio Labella
@SystemFw
it's ok, this chapter is the first "real" one
don't get discouraged
Luis point is valid in general but I don't think it applies to you
it applies to people that still struggle heavily with the syntax and semantics of basics Scala, whereas in this case I feel like you are confused by the concepts and so started getting confused by scala as well (in the run question)
that being said, it's totally ok to do just part 1 of the Red Book, then go write code/read other books, then go back to Part 2 (and then Part 3)
Renan Reis
@renanreismartins
@BalmungSan thanks for checking man... let me know if you have any other content that you find relevant.
Fabio Labella
@SystemFw

he name of this program is get, and its type is State[S, S], i.e. the sequence of transformations on S which will return S itself (which is what "getting the state" is)

I can try and explain it all though, if you want. Does the above statement make sense?

Renan Reis
@renanreismartins
@SystemFw I'm getting there dont give up on me. Yes that makes sense too.
Fabio Labella
@SystemFw
ok cool so let's resume
Renan Reis
@renanreismartins
I dont know how to compose the transformations tho
Fabio Labella
@SystemFw
we need to build def get[S]: State[S, S], and the only way we can build State computations at this point is through the constructor, which case class State[S, A](run: S => (A, S)). In this case A == S, since we want our program get to be State[S, S]
we'll get there, but if you don't understand the primitives, it's harder to see the mechanics
Renan Reis
@renanreismartins

we need to build def get[S]: State[S, S], and the only way we can build State computations at this point is through the constructor, which case class State[S, A](run: S => (A, S)). In this case A == S, since we want our program get to be State[S, S]

im with you here too

Fabio Labella
@SystemFw
so to build get, we need to pass a function of type S => (S, S) to the constructor
which, when run, will take the input state, return it as the output, and leave it unmodified for the next state
Renan Reis
@renanreismartins
corrrect.
Fabio Labella
@SystemFw
so the final definition is this
def get[S]: State[S, S] = State(s => (s, s))
see if you can reconcile it with the description above
Renan Reis
@renanreismartins

get is a function that returns State[S, S]

and to construct State, we need to pass to its constructor a function that receives S and returns (A, S). Am I correct?

Fabio Labella
@SystemFw
so far yes, but I need you to understand the specific function that I passed to State, because that function defines get specifically

will take the input state, return it as the output, and leave it unmodified for the next state

that's the English description of what it does, you need to see that same description in the code