something consistent

value

is kind of generic

but I guess people understand it

or we can keep names as they are and expose

value

with extension properties

makes sense

@hastebrot @dh44t created https://github.com/arrow-kt/arrow/issues/581

I created #arrow-contributors for those of you that are contributing or interested in discussion regarding the internals of Λrrow. We will coordinate there development efforts and the overall design and direction of Λrrow.

I have a question relating to creating an IO Monad. What is the difference between these two ways of creating the IO Monad? Are they the same?

IO.runAsync { ...  }

vs

IO.AsyncContext.runAsync { ... }

@heyitsmohit

IO.runAsync { cb -> ... }

is used take an async calback based API and use it to lift the result of the async computation whether is a succesful result or an exception into the context of

IO

The second one should not compile. The second one mentions

AsyncContext

which is the type class version describing the behavior of what

runAsync

does,

So what we have here regarding async is: IO<A>: An Async capable data type AsyncContext<F>: A type class that can lift a callback into F whatever F means for example in this case IO IOAsyncContextInstance: the global instance that adapts the behaviors of AsyncContext fullfilled by IO.

But normally when you work with IO you don't need to call

runAsync

unless you are integrating callbacks into your composition of IO or whatever other async data type such as DeferredKW or ObservableKW

Hi, I'm currently using #funktionale and would like to switch to #arrow. Is this possible without rewriting a lot of code?

more or less, depending on what you're using

what are you using?

I'll write a migration guide soon

@helpermethod we tried keeping all Funktionale api's in Arrow 0.5.5, You may just need to add some dependencies since it has been modularized and add the imports for some of the syntax but that should be it. Feel free to also ping us here and we'll help out

I'm mainly doing FP "light", i.e. I'm making heavy use of partial application and function composition (.partiallyX, andThen). Also a little bit of functional error handling (eitherTry).

I've looked into Arrow and all that Monadic stuff seems waaay over my head 😞 (well, for now at least 😉 ).

partially

and

andThen

have just package changes

eitherTry

should be now

Try {/*BOOM!!*/}.toEither()

you still can use

eitherTry

but is deprecated

Ahh,

partially1

, … are in the

arrow.syntax.function

package. Somehow the GitHub code search function could only find the tests for it.

I love GitHub but the search function is 💩

I can't second this enough! Walking through tons of the tests nearly every time I search some code. I feel that it should be faster to clone and search locally in 99% of cases.

it is faster

For those of you that plan to clone

Arrow

to do that please run first

./gradlew clean build

the first time because some of the types depend on boilerplate codegen and just opening the project in IDEA won't yield the results you want either.

looking for some guidance as im attempting to learn and apply this functional stuff piecemeal to one of my projects i have a

List<Action>

, where each

Action

is a function that is like this signature

interface Action {
  fun apply(text: String): Pair<String, Boolean>
}

where the output is the new

String

with modifications and

true

if it was modified or original

String

and the

false

if it was not modified. i just need to know if any of the

Action

produced a new result the input to the first action is text of a file i want to chain the output of each function together, for example so if i have 3 `Action`s the

String

flows through each of them. i was looking at http://arrow-kt.io/docs/datatypes/state/ which seems like what i should be using (like using

State<String, Boolean>

), but im stumbling on some of the implementation pieces, like wrapping and unwrapping the types at the boundaries and chaining the arbitrary

N

methods together what is the right approach here, and anybody have some advice for getting started?

What I do with state is to represent each step of an algorithm as a State function

@dh44t uploaded a file: Untitled