bfollington

(ns cursive-test.core
  (:require [clj-http.client :as client])
  (:require [clojure.core.async :as async]))

; setup async pipelines

(def publisher (async/chan))

(def publication
  (async/pub publisher #(:topic %)))

bfollington

module Sketch

type Step =
    | VSI
    | BusinessAddress
    | Offer
    | AccountHolder
    | BusinessDetails
    | Identity
    | Concessions

bfollington

import React, { ChangeEvent } from "react";
import "./App.css";
import { RecoilRoot, atom, useRecoilState } from "recoil";

const useRecoilReducer = <S, A>(
  reducer: (s: S, a: A) => S,
  recoilState: any
) => {
  const [state, setState] = useRecoilState(recoilState);
  const dispatch = (a: A) => {

bfollington

type User = { name: string, email: string }
type Admin = { name: string, role: string }

// Let's say hi to a user!
const greet1 = (u: User) => console.log(`Hi, ${u.name}`)

// What if we want to greet an Admin though... We can't re-use this
// What about taking a page out of C#'s book and use an interface?

interface INamed { name: string }

bfollington

import React, { useReducer } from "react";
import { messages, initialMessagesState } from "./slices/messages";

const App: React.FC = () => {
  const [messageList, dispatch] = useReducer(
    messages.reducer,
    initialMessagesState
  );

  return (

bfollington

const fs = require('fs')
const package = require('./package.json')

const projectSettingsPath = 'ProjectSettings/ProjectSettings.asset'

const re = /bundleVersion:\s(\d\.\d\.\d)$/gm

const fileStr = fs.readFileSync(projectSettingsPath, 'utf8')
const updated = fileStr.replace(re, `bundleVersion: ${package.version}`)
console.log(`bundleVersion: ${package.version}`)

bfollington

type Lens<R, K extends keyof R, O> = {
  get(action: R):O,
  set(action: R, value:O): R
}

function lens<R, K extends keyof R, O>(field: K): Lens<R, K, O> {
  return {
    get(action: R): O {
      return (action[field] as unknown) as O
    },

bfollington

function lens<K extends string>(key: K) {
  return <const>{
    get: function<R extends any>(record: R): K extends keyof R ? R[K] : unknown {
      const k: string = key
      return record[k]
    },
    set: function<R extends any>(record: R, value: R[K]) {
      return record.hasOwnProperty(key) ?
          {
            ...record,

bfollington

interface INamed<T> {
  name: T
}

export const Name = {
  get<T>(named: INamed<T>) {
    return named.name
  },
  set<T>(named: INamed<T>, value: T) {
    return {

bfollington

void Update()
{
    RaycastHit hit;
    Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

    if (Physics.Raycast(ray, out hit, 100, FloorLayer)) {
        Transform objectHit = hit.transform;

        if (SnapToGrid) {
            var newPos = new Vector3(Round(hit.point.x, GridSize), _yOffset, Round(hit.point.z, GridSize));