hex13

const reserializer = (mapping) => {
   const map = new Map();
   Object.keys(mapping).forEach(k => map.set(mapping[k], k));
   return {
      serialize: value => map.get(value),
      deserialize: value => mapping[value],      
   }
}

// application

hex13

// emulation of Go's defer in JS

// helper function 
const makeDefer = () => {
	const deferred = [];
	return {
		defer(f) {
			deferred.unshift(f);
		},
		done(result) {

hex13

macro_rules! foo {
    ($a: literal ) => {
      $a
    };
    ($op:tt $a:literal $b:tt) => {
        foo!($op ($a) $b)
    };
    ($op:tt $a:tt $b:literal) => {
        foo!($op $a ($b))
    };

hex13

const createStore = (reducer, state) => {
    let subscribers = [];
    return {
        dispatch: (action) => {
            state = reducer(state, action);
            subscribers.forEach(f => f(state));
        },
        getState: () => state,
        subscribe: (f) => {
            subscribers.push(f);

hex13

//License CC0 1.0: https://creativecommons.org/publicdomain/zero/1.0/

class Deferred extends React.Component {
    constructor(props) {
        super(props);
        this.state = {
            value: ''
        };
    }
    componentDidMount() {

hex13

'use strict';

const AC = type => {
    const ac = payload => ({type, payload}); 
    ac.type = ac().type; 
    return { [type]: ac, type }
};
  
const { addTodo, type: ADD_TODO } = AC('addTodo');
const { removeTodo, type: REMOVE_TODO } = AC('removeTodo');

hex13

import xs from 'xstream';

// If I intended to make a serious state-management system based on observables, I would probably not try to imitate Redux 
// but this was made only for self-learning and for fun.

// Redux-like store factory:

const createStore = (reducer, initial) => {
    const action$ = xs.create({start() {},stop() {}});

hex13

// someScript.funq
def hello { | @name |  
    if (2 < 3) { 
        alert "two is less than three" 
    } else {
        alert "two is not less than three"
    };
    alert ("Hello, " + @name)
};

hex13

// hoc
compose(
  withState({a: 'setA', b: 'setB'}),
  withProps(({ a, b }) => ({ c: a + b }))
);

// render function
return (
    <div>

hex13

const reducers = {
   add(state, {payload: [number]}) {
	     return state + number;
   },
};

function reducer(state, action) {
	 if (reducers.hasOwnProperty(action.type))
		   return reducers[action.type](state, action);
   return state;