buster

@axionbuster.com

constant, yet volatile

prog :: IO ()
prog = runEff . runLog . runSpan $ do
span "example program" do
log "foo"

span "greeting" do
log "hello"
log "world"

log "bar"

>>> prog
[Start span 'example program']
[LOG] foo
[Start span 'greeting']
[LOG] hello
[LOG] world
[End span 'greeting']
[LOG] bar
[End span 'example program']

"Simple and efficient purely functional queues and deques," Chris Okasaki. Abstract. We present purely functional implementations of queues and double-ended queues (deques) requiring only O(1) time per operation in the worst case. Our algorithms are considerably simpler than previous designs with the same bounds. The inspiration for our approach is the incremental behavior of certain functions on lazy lists.

$dda start end = do let fi = fromIntegral :: i -> Double difference = liftM2 (-) end start steps = maximum $ abs <$> difference step = ((/ fi steps) . fi) <$> difference v <- newSTRef `traverse` fmap fi start (succ steps,) <$> fix \this -> do v' <- traverse readSTRef v forM_ (mzip v step) \(r, s) -> modifySTRef r (+ s) (fmap round v' :) <$> this -- lazy list$

$-- | the DDA line drawing algorithm -- (dimension-independent, lazy, infinite) -- -- you can generate an infinite ray by -- ignoring the number of steps -- -- algorithm is due to Wikipedia dda :: forall f i s. (Traversable f, MonadZip f, Integral i) => -- | The starting point f i -> -- | The ending point f i -> -- | The number of steps (points) to get to the end -- and the points ST s (i, [f i]) dda start end = do let fi = fromIntegral :: i -> Double difference = liftM2 (-) end start steps = maximum $ abs <$> difference step = ((/ fi steps) . fi) <$> difference v <- newSTRef `traverse` fmap fi start (succ steps,) <$> fix \loop -> do v' <- traverse readSTRef v forM_ (mzip v step) \(r, s) -> modifySTRef r (+ s) (fmap round v' :) <$> loop -- lazy list$

if
| all id needs -> do
enqueue $ newpoint2 ex ey
unless smooth do
enqueue $ newpoint2 ey ez
enqueue $ newpoint2 ex ez
enqueue $ newpoint1 ex
enqueue $ newpoint1 ey
enqueue $ newpoint1 ez
| needs ^. el ex && needs ^. el ey -> do
enqueue $ newpoint1 ex
unless smooth do
enqueue $ newpoint1 ey
| needs ^. el ex && needs ^. el ez -> do
enqueue $ newpoint1 ex
unless smooth do
enqueue $ newpoint1 ez
| needs ^. el ey && needs ^. el ez -> do
enqueue $ newpoint1 ey
unless smooth do
enqueue $ newpoint1 ez
| otherwise -> pure ()

YouTube. A Sensible Introduction to Category Theory by Oliver Lugg.

Comment. Is this object oriented mathematics?

1945 SIGSALY 1946
SPEECH ENCIPHERMENT SYSTEM
A lectern surrounded by walls made of hardware

$extrapoints :: STRef s (Seq IP) <- new Seq.empty -- right-to-left, FIFO out :: STRef s [IP] <- new [] callCC \break_ -> do let break = break_ () fix \continue -> do let tell = write out read extrapoints >>= \case a :<| points -> do tell [a] if sameblock a end then break else continue _ -> pure () -- todo... break$