JonathanLorimer

[error]         at sbt.Execute.$anonfun$submit$2(Execute.scala:282)
[error]         at sbt.internal.util.ErrorHandling$.wideConvert(ErrorHandling.scala:23)
[error]         at sbt.Execute.work(Execute.scala:291)
[error]         at sbt.Execute.$anonfun$submit$1(Execute.scala:282)
[error]         at sbt.ConcurrentRestrictions$$anon$4.$anonfun$submitValid$1(ConcurrentRestrictions.scala:265)
[error]         at sbt.CompletionService$$anon$2.call(CompletionService.scala:64)
[error]         at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:317)
[error]         at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:577)
[error]         at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:317)
[error]         at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1144)

JonathanLorimer

Deliverer Assets	Deliverer Liabilities	Payee Assets	Payee Liabilities	Payer Assets	Payer Liabilities	Taker Assets	Taker Liabilities	Description
				+100		-100		export of goods
					+100	+100		taker opens foreign account
-100						+100		payment in currency
+100

JonathanLorimer

:3000 {
	log {
		output stdout
		level DEBUG
	}

	header {
		Access-Control-Allow-Origin localhost:3000
	}

JonathanLorimer

evaluating pointer: a
evaluating pointer: lx
Or: Or (Literal (Pointer "lw")) (Literal (Pointer "lv"))
evaluating pointer: lw
LShift: LShift (Literal (Pointer "lc")) (Literal (Signal 1))
evaluating pointer: lc
Or: Or (Literal (Pointer "lb")) (Literal (Pointer "la"))
evaluating pointer: lb
LShift: LShift (Literal (Pointer "kh")) (Literal (Signal 1))
evaluating pointer: kh

JonathanLorimer

--- Day 7: Some Assembly Required ---

This year, Santa brought little Bobby Tables a set of wires and bitwise logic gates! Unfortunately, little Bobby is a little under the recommended age range, and he needs help assembling the circuit.

Each wire has an identifier (some lowercase letters) and can carry a 16-bit signal (a number from 0 to 65535). A signal is provided to each wire by a gate, another wire, or some specific value. Each wire can only get a signal from one source, but can provide its signal to multiple destinations. A gate provides no signal until all of its inputs have a signal.

The included instructions booklet describes how to connect the parts together: x AND y -> z means to connect wires x and y to an AND gate, and then connect its output to wire z.

For example:

JonathanLorimer

public export
data Fix : (Type -> Type) -> Type where
  Fx : f (Fix f) -> Fix f

public export
unfix : Fix f -> f (Fix f)

public export
interface (Functor f) => Recursive (f : Type -> Type) (t : Type) where
  project : t -> f t

JonathanLorimer

Cabal Reference Summaries

- Old Cabal User Guide
  - Section 1
    - `cabal init` & `cabal run`
    - Adding dependencies to a cabal file
    - Relationship of `Main.hs` to `cabal run`
  - Section 2
    - `cabal install` command
      - Local

JonathanLorimer

Cabal User Guide

- Old Cabal User Guide
  - Section 1
    - `cabal init` & `cabal run`
    - Adding dependencies to a cabal file
    - Relationship of `Main.hs` to `cabal run`
  - Section 2
    - `cabal install` command
      - Local

JonathanLorimer

title	author	date	datePretty	description	tags
Intro to FP Through λ-Calc Part 1. - Motivating Laziness	Jonathan Lorimer	19/03/2020	Mar 19, 2020	Introduction to Functional Programming Through Lambda Calculus gave a thorough explanation of evaluation in lambda calculus, I found this helped motivate a better understanding of evaluation in haskell!	lambda-calculus

Table of Contents

JonathanLorimer

const productType = { a: 3, b: "hello", c: false } 
// this has the implied type data ProductType = { a :: Number, b :: String, c :: false }
// even if javascript doesn't demand that we think about it, it matters
// as demonstrated by the below function which IMPLICITLY expects that type signature

const repeatWord = ({a, b, c}) => b + (c ? " " : "/n") + (a <= 0 ? "" : repeatWord({a: a - 1, b, c})
// if you give the above function the wrong 'type' you will get unexpected behaviour
// rather than resulting in a type error you will get either a runtime error or an unexpected return value
                                                          
// Similarly you might have this