Discord is now Scala’s main chat platform. Please join us at https://discord.com/invite/scala
like, there's three aspects here, which are related but independent
I loved the "Quick quiz: Do computer programmers use functions?" part
it helped me realise that we cannot apply the kind of algebra I remembered from school (applications, sets, groups, rings, fields) but needed an higher level of abstraction
and from there, objects, arrows are straightforward, then come the Functor... not saying it's trivial, but definitely helps :)
anyway, there's three aspects:
- what is referential transparency, and why it matters. This is key. It's the foundational principle of pure FP, where most of its advantages comes from, and everything else comes back to this.
- why do effects - representing computations with higher kinded types of shape
F[A](kind* -> *) - matter. This is the most neglected part, everyone's talking about "monads", in ways that generate lots of confusion. A good treatment of this helps you tremendously understanding the rest - why does Monad matter, as opposed to Functor, Applicative, Monoid, Arrow, and the other typeclasses. If you understand the first two points, explaining the extra power (and subsequent compositional limitations) that Monad has compared to other algebras is easy. The essence of what they give you.
also, we can apply the kind of algebra you refer to,
Monoid being an example
category theory can be useful to connect things, but it's not required to become an FP expert imho
it's not a bad explanation by any means
but I'm talking about things of shape
F[A] as a standalone entities, as well as their relationship with typeclasses/algebras, especially the fact that algebras describe part of their behaviour, but some things are specific to each concrete datatype <-- failure to understand this leads to the "how do I get this value out of IO" fallacy
the need is to have def isEffect(t: Type): Boolean = true if there is an Effect[t], at runtime
type class resolution is always compile time because that's how we resolve implicits, afaik
Nothing is stopping you to define a type class
Exists:trait Exists[A] { def apply(): Boolean }
object Exists extends Nope {
implicit def sure[A](implicit a: A): Exists[A] = new Exists[A] {
def apply() = true
}
}
trait Nope {
implicit def nope[A]: Exists[A] = new Exists[A] {
def apply() = false
}
}
then you can do
def isEffect[T](implicit isIt: Exists[Effect[T]]) = isIt()
they want it at runtime
it's the same
rho issue
when
rho only had Task
it's been asked by several people several times, and still no solution :(
this is for the implementation of swagger support in rho iirc (might be wrong here)
And that's actually the other way around: I have a value and I want to see if the typeclass resolves for its runtime type, which is of course impossible in general.
It's definitely a very very niche case
I agree it's not possible, you'd need something like
TypeTag, which would need to also capture typeclass instances
trait TagHandler {
def success(x: Any): Unit
def failure(reason: Throwable): Unit
}
abstract class StandardTagHandler(val pfAllowedStates : PartialFunction[State, Unit]) extends TagHandler {
def sth_success(x : Any) : Unit
def success(x : Any) : Unit =
if (pfAllowedStates.isDefinedAt(state)) sth_success(x)
else resetToInit(s"$this called in unallowed state $state")
def failure(reason : Throwable) : Unit = {
resetToInit(s"$this failed with reason : $reason")
}
}
this is inside a FSM class that has a
state : State . i want to make this intermediate StandardTagHandlerclass so I don't keep rewriting the state check boiler plate
is this is right way to use the partialFunction? or should it be
State => Boolean check or something like that
I think the consensus is that it's not possible
it depends on what your state transitions look like. If you have
State1 <: State etc, you could have a class StateTransition[A, B], have the method that does a state transition from From to To take an implicit StateTransition[From, To], and have a bunch of implicit object transitionFromTo extends StateTransition[From, To] for the allowed transitions
those could be phantom types too
