easiest way is a case statement, if you search for "routing" there are several discussions

we have a hyperfiddle.router coming for complex route compositions but it's not ready

core.match also works

there is a goog.history integration under the contrib namespace

case+`reitit`

I learned how to do it from this example: https://github.com/jeans11/demo-rama-electric/blob/main/bases/web-ui/src/dre/web_ui/routes.cljc (reitit frontend based)

Hi, You can use that template: https://github.com/Bariscanates404/param-routing-electric-datomic-template History router

Strictly speaking, maybe possible. Macros not strictly needed, the compiler can be language-external (i.e. Babel). Immutability-by-default is important to the reactive dataflow semantics. Mutation tracking (for imperative langs such as JS or WASM) is a hard unsolved problem, only beginning to be tackled in the literature i've seen. So technology is not there yet. More loosely speaking, perhaps a 65% good enough solution could get adoption in mainstream, but you'd still need a modern concurrency library and there's nothing good enough in JS that I've seen (we use Missionary which is the state of art, years ahead of effect-ts)

Clojure is the right place to do an experiment like this and be able to move reasonably quickly, and in a commercial setting with PL enthusiasts to early adopt and talk to us while we figure out the design, etc

this is what i have currently, which doesn't do any accumulation

(let [!q (atom "htht")
      q  (e/watch !q)]
  (letfn [(random-delayed-seed [fixed-delay variable-delay xs]
            (m/ap
              (m/?
               (let [x (m/?> (m/seed xs))]
                 ;; order matters here
                 (m/sleep
                  (+ fixed-delay (rand-int variable-delay))
                  x)))))]
    (when-some [x
                (->> q
                  (random-delayed-seed 50 150)
                  (m/reductions str "")
                  new)]
      (js/console.log x)
      (div (text x))))
  (div (text q))
  (dom/input
   (dom/on "keydown"
     (e/fn [e]
       (when (= "Enter" (.-key e))
         (reset! !q (.. e -target -value)))))))

josh this is really interesting what's your desired outcome? trickle-write of any streamed input in any asynchronous order received?

yep

(for llms)

is there a good reason the llm would give you a strange output sequence ? or is that more of a design consideration.

lmao it's a result of a hack i am doing for our project

long story

it's a very strange use case

but very critical for our use case

also a hunch that this is much more easily solved using differential electric

how do we know the appropriate sequence of stuff? is everything tagged with a sequence number on the way in?

yeah s1 s2 s3 are sequential inputs

reset! of an atom

Oh okay, they are coming in in the correct sequence already, gotcha. I reckon putting it on a channel is the right answer

i haven't dealt with channels too much, how would i do that?

basically using put and take to load and unload the chan

how does that translate to electric

\ are there examples?

put and take utilize go blocks, i wonder abt electric examples

i am assuming just reset! of atom is not enough because it'll completely forget about previous values

yeah some sort of state tracking

seems necessary

yeah

told chatGPT4 to generate an example with put and take, does it look right ?

(ns your-namespace
  (:require [clojure.core.async :refer [chan put! take! go]]
            [cljs-http.client :as http]))

(defn get-llm-response [request]
  ;; Function to get a response from the LLM (simulated here as an HTTP request)
  ;; In a real scenario, you would replace this with an actual HTTP request to the LLM API
  (http/get ""
            {:params {:query request}}))

(defn process-llm-response [response]
  ;; Function to process the response from the LLM
  (println "Received response from LLM:" response))

(defn send-request-to-llm [request channel]
  ;; Function to send a request to the LLM and put the response into the channel
  (go (let [response (<! (get-llm-response request))]
        (put! channel response))))

(defn main []
  ;; Main function to demonstrate put! and take!
  (let [channel (chan)] ; Create a new channel
    ;; Send a request to the LLM
    (send-request-to-llm "Hello LLM" channel)

    ;; Take the response from the channel and process it
    (go (let [response (<! channel)]
          (process-llm-response response)))))

(main)

lols

can't quite figure it out...

(let [!q (atom "htonuehto")
      q  (e/watch !q)
      ch (a/chan)]
  (div (text ch))
  (letfn [(random-delayed-seed [fixed-delay variable-delay xs]
            (m/ap
              (m/?
               (let [x (m/?> (m/seed (m/?> xs)))]
                 (m/sleep
                  (+ 20 (rand-int 200))
                  x)))))]
    (when-some [x
                (->> (channel-flow ch)
                  (random-delayed-seed 50 150)
                  (m/reductions str "")
                  new)]
      (js/console.log x)
      (div (text x))))
  (div (text q))
  (dom/input
   (dom/on "keydown"
     (e/fn [e]
       (when (= "Enter" (.-key e))
         (a/put! ch (.. e -target -value)))))))

hmm

i think you're on the right track

not sure about new)

i think channel-flow doesn't work in cljs

this code

(defn forever [task]
  (m/ap (m/? (m/?> (m/seed (repeat task))))))

(defn- take! [chan]
  (m/via
      m/blk
    (let [r (a/<!! chan)]
      (if (nil? r)
        (throw (ex-info "take cancelled, channel closed" {:cancelled? true}))
        r))))

(defn channel-flow [ch-recv]
  (forever (take! ch-recv)))

new converts it to electric value

whatever it is, i keep getting #object[Error Error: Unsupported operation.] core.cljs:200:23

hmmm

omg i did it

i haven't used my brain this much since my operating systems class lmaooooo

yay

great job

all i was missing was e/fn [] that turned it into a flow

Oh very cool)

(m/seed (m/?> xs)) is just xs

@U09FL65DK i am noticing difference in behavior between those two