andrejewski

import React from 'react'
import react from 'raj-react'
import { union } from 'tagmeme'
import { mapEffect } from 'raj-compose'

export function loadModelsForMake (id) {
  return function (dispatch) {
    window.fetch(`/models?id=${id}`)
      .then(res => res.json())
      .then(res => {

andrejewski

function createLoader (keysTask) {
  let keys = []
  let nextTaskPromise

  return {
    load (key) {
      const index = keys.push(key) - 1;

      if (!nextTaskPromise) {
        let resolver

andrejewski

import Map from 'can/map/';
import Component from 'can/component/';

const viewModel = Map.extend('CanDeferVM', {
  define: {
    delayMs: {
      value: 0,
      set: x => parseInt(x, 10)
    },

andrejewski

import { program } from 'https://gist.github.com/andrejewski/5455ccdef77122389b1ac8a7b5ff8415'

// Functional | Reductionist
program(DefineMap, () => ({
  init: [{
    name: '',
    nameChangeCount: 0
  }],
  update: (msg, model) => [{
    name: msg,

andrejewski

/*
  Another day spent on declarative subscriptions.
  This implementation works like this:
  
  subscription({
    program: myProgram,
    subscription: {
      foo: sub1,
      bar: sub2
    },

andrejewski

/*

select table_name
from information_schema.tables
where table_type = 'BASE TABLE' and table_schema = 'public';

resources {
  id serial primary key,
  type text not null
}

andrejewski

What is Raj

Raj solves two problems: state management and running side-effects. These problems are the hardest problems in building client applications.

State management is two things: storing state and handling state transitions. Raj holds a single variable called state which stores the application state. Raj will update this variable as messages are dispatched. State transitions are synchronous and preferably written in an immutable manner as to be simple to test quickly.

andrejewski

How do Raj and Redux compare performance wise?

Raj is faster theoretically. In Redux you have N reducers that need to be iterated, in Raj you have a single update which can call sub graph updates (log N). Redux also can have multiple subscriptions whereas Raj doesn't have any. Looking at code size and the amount of work each project does and the list-vs-tree distribution of work, Raj should be better.

Also since (logic+view+data) assemble into Raj programs, it's easier to code-split and lazy-load. There's no definite story for how to do at in Redux. In Raj, you use raj-spa where a program can resolve from a promise.

Is there a way to apply Raj to a backend state machine where there is no view?

So view is mostly for apps with UIs. It is a side-effect that receives the whole state as opposed to plain effects which need portions of state explicitly passed. If you don't need a view, you can think of it like a "window" into the current state. For example, you can have something like tapProgram wh

andrejewski

exports.createEmitter = function createEmitter ({ shouldPrime, initialValue }) {
  let currentValue = initialValue
  let listeners = []

  return {
    emit: value => () => {
      currentValue = value
      listeners.forEach(listener => listener(currentValue))
    },

andrejewski

function createReconciler ({
  mergeEntity,
  getEntityKey,
  
  entityStore = {},
  subscriptions = new Set(),
}) {
  function notify (subscriptions) {
    subscriptions.forEach(subscription => {
      const entities = []