ToCode

import textReducer from './slices/text';
import saveForLaterReducer from './slices/save_for_later';
import { actions } from './slices/save_for_later';
import { actions as textActions } from './slices/text';

export const store = configureStore({
  reducer: {
    text: textReducer,
    saveForLater: saveForLaterReducer,
  },
})

setTimeout(() => {
  store.dispatch(actions.enqueue(textActions.change("New text from server")));
}, 5000);

// Infer the `RootState` and `AppDispatch` types from the store itself
export type RootState = ReturnType<typeof store.getState>
// Inferred type: {posts: PostsState, comments: CommentsState, users: UsersState}
export type AppDispatch = typeof store.dispatch

import './App.css'
import { useSelector, useDispatch } from 'react-redux'
import { RootState, AppDispatch } from './redux/store';
import { actions } from './redux/slices/text';
import { runPending } from './redux/slices/run_pending_thunk';
const useApplicationDispatch: () => AppDispatch = useDispatch;

function App() {
  const dispatch = useApplicationDispatch();
  const text = useSelector((state: RootState) => state.text.value);
  const hasPendingActions = useSelector((state: RootState) => state.saveForLater.pending.length > 0);

  const sync = () => {
    dispatch(runPending());
  }

  return (
    <div className="App">
      {hasPendingActions && (
      <p>
        New text from server available.
        <button onClick={sync}>Click To Sync</button>
      </p>)}
      <input type="text" value={text} onChange={(e) => dispatch(actions.change(e.target.value))} />
    </div>
  )
}

export default App

enqueue(state, action: PayloadAction<Action>) {
  state.pending.push(action.payload);
}

// file: src/redux/slices/text
import { createSlice } from '@reduxjs/toolkit'
import type { PayloadAction } from '@reduxjs/toolkit'

export interface TextState {
  value: string
}

const initialState: TextState = {
  value: "Hello World",
}

export const slice = createSlice({
  name: 'text',
  initialState,
  reducers: {
    change(state, action: PayloadAction<string>) {
      state.value = action.payload;
    }
  },
})

// Action creators are generated for each case reducer function
export const actions = slice.actions
export default slice.reducer

// file: src/redux/slices/save_for_later.ts

import { createSlice, PayloadAction } from '@reduxjs/toolkit'
import type { Action } from '@reduxjs/toolkit'
import { clearPending } from './run_pending_thunk';

export interface SaveForLaterState {
  pending: Array<Action>;
}

const initialState: SaveForLaterState = {
  pending: [],
}

export const slice = createSlice({
  name: 'saveForLater',
  initialState,
  reducers: {
    enqueue(state, action: PayloadAction<Action>) {
      state.pending.push(action.payload);
    }
  },
  extraReducers: (build) => {
    build.addCase(clearPending, () => {
      return initialState;
    })
  }
})

// Action creators are generated for each case reducer function
export const actions = slice.actions
export default slice.reducer

// file: src/redux/slices/run_pending_thunk.ts

import { createAction, createAsyncThunk } from "@reduxjs/toolkit";
import { RootState } from "../store";

export const clearPending = createAction('saveForLater/clearPending');

export const runPending = createAsyncThunk<void, void, {state: RootState }>('saveForLater', async (arg: void, { getState, dispatch }) => {
  const pending = getState().saveForLater.pending;
  pending.forEach(dispatch);
  dispatch(clearPending());
});

// file: src/redux/store.ts

import { configureStore } from '@reduxjs/toolkit'

User = Data.define(:name, :email)

u1 = User.new(name: 'dave', email: 'dave@e.com')
u2 = User.new(name: 'john', email: 'john@e.com')

puts u1.email

puts "u1 == u2 ? #{u1 == u2}"

[?dir :entry/name ?name]
       [?dir :entry/type :entry-dir]
       (inside ?child ?dir)
       [?child :entry/size ?size]] (d/db conn) rules)

(d/q '[:find ?name (sum ?size)
       :in $ %
       :where
       [?dir :entry/name ?name]
       [?dir :entry/type :entry-dir]
       (inside ?child ?dir)
       [?child :entry/size ?size]] (d/db conn) rules)
       
;; returns [["" 48381165] ["a" 94853] ["d" 24933642] ["e" 584]]
       

(ns main
  (:require [datomic.api :as d]))

(def db-uri "datomic:mem://fs99")

(d/create-database db-uri)

(def conn (d/connect db-uri))

(def schema
  [
   {:db/ident :entry/type
    :db/valueType :db.type/ref
    :db/cardinality :db.cardinality/one}
   {:db/ident :entry/name
    :db/valueType :db.type/string
    :db/cardinality :db.cardinality/one}
   {:db/ident :entry/link-to
    :db/valueType :db.type/ref
    :db/cardinality :db.cardinality/one}
   {:db/ident :entry-link}
   {:db/ident :entry-file}
   {:db/ident :entry-dir}
   {:db/ident :entry/parent
    :db/valueType :db.type/ref
    :db/cardinality :db.cardinality/one}
   {:db/ident :entry/size
    :db/valueType :db.type/long
    :db/cardinality :db.cardinality/one}
   {:db/ident :fs/id
    :db/cardinality :db.cardinality/one
    :db/unique :db.unique/identity
    :db/valueType :db.type/string}
   {:db/ident :fs/cwd
    :db/cardinality :db.cardinality/one
    :db/valueType :db.type/ref}
   ])

@(d/transact conn schema)

(defn cwd []
  (let [db (d/db conn)]
    (d/q '[:find ?cwd .
           :where
           [?fs :fs/id "/"]
           [?fs :fs/cwd ?cwd]] db)))

(defn file [name size]
  @(d/transact conn [
                     {:entry/type :entry-file
                      :entry/name name
                      :entry/size size
                      :entry/parent (cwd)}
                     ]))

(defn dir [name]
  @(d/transact conn [
                     {:entry/type :entry-link
                      :entry/parent "d"
                      :entry/name ".."
                      :entry/link-to (cwd)}
                     {:entry/type :entry-link
                      :entry/parent "d"
                      :entry/name "."
                      :entry/link-to "d"}
                     {:db/id "d"
                      :entry/type :entry-dir
                      :entry/name name
                      :entry/parent (cwd)}
                     ]))


(defn cd [name]
  (let [db (d/db conn)
        to (d/q '[:find ?e .
                  :in $ ?cwd ?name
                  :where
                  [?e :entry/name ?name]
                  [?e :entry/parent ?cwd]]
                db
                (cwd) name)
        toe (d/entity db to)
        tod (if (= (:entry/type toe) :entry-link)
              (:db/id (first (filter #(= (:entry/type %1) :entry-dir) (iterate :entry/link-to toe))))
              to)]
    @(d/transact conn [{:fs/id "/"
                        :fs/cwd tod}])))

(def data [
           {:db/id "root" :entry/name "" :entry/type :entry-dir}
           {:fs/id "/" :fs/cwd "root"}
           ])

@(d/transact conn data)

(dir "a")
(file "b.txt" 14848514)
(file "c.dat" 8504156)
(dir "d")
(cd "a")
(dir "e")
(file "f" 29116)
(file "g" 2557)
(file "h.lst" 62596)
(cd "e")
(file "i" 584)
(cd "..")
(cd "..")
(cd "d")
(file "j" 4060174)
(file "d.log" 8033020)
(file "d.ext" 5626152)
(file "k" 7214296)

(d/q '[:find ?name :where
       [?e :entry/type :entry-file]
       [?e :entry/name ?name]] (d/db conn))

(def rules
'[[(belongs-to ?entry ?parent)
   [?entry :entry/parent ?parent]]
  [(inside ?entry ?parent)
   (belongs-to ?entry ?parent)]
  [(inside ?entry ?parent)
   (belongs-to ?entry ?middle)
   (inside ?middle ?parent)]])

(d/q '[:find ?name (sum ?size)
       :in $ %
       :where

[?fs :fs/cwd ?cwd]] db)))

(defn file [name size]
  @(d/transact conn [
                     {:entry/type :entry-file
                      :entry/name name
                      :entry/size size
                      :entry/parent (cwd)}
                     ]))

(defn dir [name]
  @(d/transact conn [
                     {:entry/type :entry-link
                      :entry/parent "d"
                      :entry/name ".."
                      :entry/link-to (cwd)}
                     {:entry/type :entry-link
                      :entry/parent "d"
                      :entry/name "."
                      :entry/link-to "d"}
                     {:db/id "d"
                      :entry/type :entry-dir
                      :entry/name name
                      :entry/parent (cwd)}
                     ]))

(defn cd [name]
  (let [db (d/db conn)
        to (d/q '[:find ?e .
                  :in $ ?cwd ?name
                  :where
                  [?e :entry/name ?name]
                  [?e :entry/parent ?cwd]]
                db
                (cwd) name)
        toe (d/entity db to)
        tod (if (= (:entry/type toe) :entry-link)
              (:db/id (first (filter #(= (:entry/type %1) :entry-dir) (iterate :entry/link-to toe))))
              to)]
    @(d/transact conn [{:fs/id "/"
                        :fs/cwd tod}])))

(def data [
           {:db/id "root" :entry/name "" :entry/type :entry-dir}
           {:fs/id "/" :fs/cwd "root"}
           ])

@(d/transact conn data)

(def rules
'[[(belongs-to ?entry ?parent)
   [?entry :entry/parent ?parent]]
  [(inside ?entry ?parent)
   (belongs-to ?entry ?parent)]
  [(inside ?entry ?parent)
   (belongs-to ?entry ?middle)
   (inside ?middle ?parent)]])

$ cd /
$ ls
dir a
14848514 b.txt
8504156 c.dat
dir d
$ cd a
$ ls
dir e
29116 f
2557 g
62596 h.lst
$ cd e
$ ls
584 i
$ cd ..
$ cd ..
$ cd d
$ ls
4060174 j
8033020 d.log
5626152 d.ext
7214296 k

(def schema
  [
   {:db/ident :entry/type
    :db/valueType :db.type/ref
    :db/cardinality :db.cardinality/one}
   {:db/ident :entry/name
    :db/valueType :db.type/string
    :db/cardinality :db.cardinality/one}
   {:db/ident :entry/link-to
    :db/valueType :db.type/ref
    :db/cardinality :db.cardinality/one}
   {:db/ident :entry-link}
   {:db/ident :entry-file}
   {:db/ident :entry-dir}
   {:db/ident :entry/parent
    :db/valueType :db.type/ref
    :db/cardinality :db.cardinality/one}
   {:db/ident :entry/size
    :db/valueType :db.type/long
    :db/cardinality :db.cardinality/one}
   {:db/ident :fs/id
    :db/cardinality :db.cardinality/one
    :db/unique :db.unique/identity
    :db/valueType :db.type/string}
   {:db/ident :fs/cwd
    :db/cardinality :db.cardinality/one
    :db/valueType :db.type/ref}
   ])

(dir "a")
(file "b.txt" 14848514)
(file "c.dat" 8504156)
(dir "d")
(cd "a")
(dir "e")
(file "f" 29116)
(file "g" 2557)
(file "h.lst" 62596)
(cd "e")
(file "i" 584)
(cd "..")
(cd "..")
(cd "d")
(file "j" 4060174)
(file "d.log" 8033020)
(file "d.ext" 5626152)
(file "k" 7214296)

(defn cwd []
  (let [db (d/db conn)]
    (d/q '[:find ?cwd .
           :where
           [?fs :fs/id "/"]

(d/q '[:find ?title :where [_ :post/title ?title]] (d/db conn))

;; returns: #{["second post"] ["rust"] ["first post"]}

(d/q '[:find ?title ?slug :where
       [?p :post/title ?title]
       [?p :post/slug ?slug]] (d/db conn))
       
;; returns #{["rust" "rust"] ["second post" "second"] ["first post" "first"]}

(d/q '[:find ?title ?slug :where
       [_ :post/title ?title]
       [_ :post/slug ?slug]] (d/db conn))

;; returns
;; #{["rust" "first"] ["rust" "rust"] ["first post" "second"] ["second post" "rust"] ["first post" "rust"] ["second post" "first"] ["second post" "second"] ["rust" "second"] ["first post" "first"]}

(d/q '[:find ?title :where
       [?p :post/title ?title]
       [?p :post/categories ?c]
       [?s :subscriber/email "all@demomail.com"]
       [?s :subscriber/categories ?c]] (d/db conn))

;; returns #{["second post"] ["rust"] ["first post"]}

@(d/transact conn [
                   {:subscriber/email "clojure@demomail.com"
                    :subscriber/received {:db/id [:post/slug "first"]}}])

(d/q '[:find ?title :where
       [?p :post/title ?title]
       [?s :subscriber/email "clojure@demomail.com"]
       [?s :subscriber/received ?p]] (d/db conn))

;; #{["first post"]}

(d/q '[:find ?post-slug
       :where
       [?subscriber :subscriber/email "clojure@demomail.com"]
       [?subscriber :subscriber/categories ?cat]
       [?post :post/categories ?cat]
       (not-join [?subscriber ?post]
                 [?subscriber :subscriber/received ?post])
       [?post :post/slug ?post-slug]] (d/db conn))
       
;; returns #{["second"]}