adam-nathan

Recall that the definition of the Y combinator is

    x   = f x       -- fixed-point
    Y f = f (Y f)

The simplest recursion is

    x = x   -- [error: cannot reference a symbol before it is defined]

Create a function repeat that takes a function that calls itself.

	# Eulerian tour algorithm https://en.wikipedia.org/wiki/Eulerian_path
	def eulerian_tour(root: TreeNode) -> List[TreeNode]:
	tour = []
	def dfs(node: TreeNode, depth: int) -> None:
	tour.append((node.val, depth))
	if node.left:
	dfs(node.left, depth + 1)
	tour.append((node.val, depth))
	if node.right:
	dfs(node.right, depth + 1)

	segs ← ⊃,/∘(⍳∘≢,/¨⊂)
	segs ← (⊃,/)⍳∘⊃∘⌽∘⍴,/¨⊂ ⍝ works for matrix also
	freq ← ((⎕C ⎕A)∘.=⊢)
	mseg ← {⎕IO←0 ⋄ (⍳∘≢⍵)∘.{⍺↓⍵},\⍵} ⍝ all subvectors in correct position
	bits ← 2∘⊥⍣¯1

	pdf←{
	⍺←(0 1)
	nom←⍤-2÷⍨∘2
	denom←0.5*⍨○2


	bluebird = s (k s) k
	blackbird = bluebird bluebird bluebird
	bunting = bluebird blackbird bluebird
	becard = bluebird dove bluebird
	cardinal = starling (dove starling) (kestrel kestrel)
	dove = bluebird bluebird
	dickcissel = bluebird dove
	dovekies = dove dove
	eagle = bluebird blackbird

	open System
	let rnd = Random()
	let randint<'a> =
	print "generating random number"
	rnd.Next(0,10)

	type Signal = Signal with
	member __.Return x = x
	member __.Delay (f:unit -> _) = f

	let todo<'a> : 'a = Unchecked.defaultof<'a>
	let print x = printfn $"{x}"

	import scala.util.DynamicVariable

	class Signal[T](expr: => T) {
	import Signal._
	private var myExpr: () => T = _
	private var myValue: T = _
	private var observers: Set[Signal[_]] = Set()
	private var observed: List[Signal[_]] = Nil
	update(expr)