I don't know if there is another issue but here is one with one option to overload the cast function (in sqldelight dialect): https://github.com/cashapp/sqldelight/issues/3421#issuecomment-1214295014

I’m running into a strange error with okio on iOS. I need to create a folder if it doesn’t exist, so I have a line that says

if(!fileSystem.exists(path)) fileSystem.createDirectory(path, true)

. I also have a log on the line before printing the value of the exists check. In my logs, I see

Does it exist yet? false
Uncaught Kotlin exception: okio.IOException: File exists

I know that this function will only run on the main thread, so it’s not a threading issue, and I’m using FileSystem.SYSTEM on iOS. If I set mustCreate to false, then it runs the createDirectory line, but no folder is created. Logs also show that the parent path exists and is definitely in my app’s folder.

Playing around with Molecule (0.5.0-beta01) in a KMP lib. I can write

@Composable

functions in my

commonMain

,

iosMain

and

jsMain

sourceSets, but not in

androidMain

(Unresolved reference: Composable). Do I need to add an explicit Compose dependency to

androidMain

but not the others?

I started discussing zipline with some of my colleagues on the iOS side of the company, and their immediate concern was that Apple would remove our app because of Guideline 2.4.5:

(iv) They may not download or install standalone apps, kexts, additional code, or resources to add functionality or significantly change the app from what we see during the review process.

I think there were a few mentions of this in https://www.droidcon.com/2022/09/29/dynamic-code-with-zipline/; is it as simple as interpreting the js that makes Apple OK with it, or is there still a risk of getting removed from the App Store over using Zipline?

the guidelines used to carve out explicitly interpreted content such as JS engines and Lua. we're mostly relying on the fact that React Native ships their Hermes engine to a million apps and there's already quite a few embedding QuickJS themselves. you don't need a JS engine to significantly change the functionality of your apps, you can do that with plain code. I think users of JS engines are overly careful to ensure they don't violate that rule so as to not draw undue attention on themselves. what's the difference between an interpreting JS engine and some "native" code which iterates a series of JSON and protos and conditionally performs operations and displays content? very little.

you can read about it a little at https://dev.to/alastaircoote/to-jsc-or-not-to-jsc-running-javascript-on-ios-in-2020-44ba and https://www.theregister.com/2017/06/07/apple_relaxes_developer_rules/

@grahamborland should not be required. do you have the

google()

repo available? The Android variant uses the Google runtime which comes from Google Maven. if it failed to resolve it may not work in Android-specific source sets

Are there any redwood artifacts published, or if I want to play around with it I need to build and publish locally?

only snapshots

there's no reason why we cannot make a release, though. i guess the big problem is that it's hard to know when. things are constantly in flux right now as big things are still landing and we don't have a lot of spare capacity for writing up change logs and migration guides

You could take the CfD approach and just not do change logs or migration guides :trollface:

So until there's a stable release the snapshots will always just be the tip of trunk?

yep. we pubilsh releases internally as needed for now which can be anywhere from once a week to a few times a week. but that's also because we're still establishing the boundaries and responsibilities of its APIs

Are the snapshots supposed to be published with the build workflow? Looks like that is just publishing to maven local, and the latest snapshot in nexus is from 09/08/2022

ah yeah someone updated the publish plugin and broke it

Hi I have a question regarding how you guys use molecule Suppose you have a interactable state (can be changed by user inputs)

search

I see in all of your presentation that you guys declared inside the composable like this:

@Composable
fun present(event: Flow<Foo>) {
   var search by remember { mutableStateOf(") }
   ...
}

Why do this? Won't this make it hard to split the code into smaller chank? Suppose we have lot of events that modify

search

like

CollectEffect(event) {
 when (it) {
     Event A -> search = it.query
     Event B -> {
         saveToRecentSearch()
         search = ""
     }
     Event C -> ...
  }
}

We can't extract event B into a completly different function because

search

is inside the

present

function I'm a bit confused about this, thank you

Just pass what you need as parameters?

@Benoit Quenaudon but the new function won't be able to modify the

search

? except if i put lamda parameter

fun bar(search: String) {
  saveToRecentSearch(search)
  search = "" // Can't do
}

fun bar(search: String, changeSerch: (String) -> Unit { // Possible but a bit painful as I need to write `search = it` in the collect efect
  saveToRecentSearch(search)
  changeSearch("")
}

I cannot think of something else right now but you could pass a lambda as you said

fun something(searchSetter: (String) -> Unit)

and call that. I don’t really know how to set a mutableState field manually but if that’s easy, you woudn’t use the delegate on search and would be able to pass

MutableState<String>

to the method.

That’s maybe why lots of Android examples are using lambdas

There's other option where we can do this if we put the state declaration in the class level:

class Presenter: MoleculePresenter {
  var search by mutableStateOf(")

   @Composable
   fun present(event: Event): State {
      CollectEffect(event) {
         when(event) {
            eventB()
         }
      }

      ...
   }
   
   private fun eventB() {
      saveToRecentSearch(search)
      search = ""
   }
}

But after seeing lot of presentation from cashapp or regarding molecule, none of them are doing this so I'm curious why they didn't do this

That won’t compile I think. You cannot do

search = ""

without delegates.

updated, but my points still stand

I don’t think so?

There’s no lifecycle outside of the composable method

the recomposition also works normally just like when we put inside function declaration with remember

Got it, then why not

thats my question, why not, why not do this in cashapp? I was wondering if there's a gotcha or benefit if we put inside the composable function

The only thing I could think of and which I’m not sure about is around potential problems if the lifecycle of the presenter is different from the calling site of the composable method. Molecule presenters are still pretty recent so we’re still discovering edge cases, so it’s totally possible none of us ran into this yet or didn’t notice it