Paul Chiusano pchiusano

Unison computations can hop between nodes, can fail, can be forked to execute asynchronously, and can be supervised:

-- Promote a pure value to `Remote`
Remote.pure : ∀ a . a -> Remote a

-- Sequencing of remote computations
Remote.bind : ∀ a b . (a -> Remote b) -> Remote a -> Remote b

-- The current node where the computation is executing

Hi all!

After a very lengthy period of development and testing, FS2 (formerly scalaz-stream) version 0.9 is finally out! Here's how to get it.

For this release, the library has undergone a major redesign. Check out the migration guide for more info, and also the shiny new user guide. Going forward, we expect the API of the library will be quite stable and hope it becomes one of the bedrock libraries of the Scala ecosystem. The 0.9 series has already seen production use as well as a huge amount of testing during the development process; we feel very good about recommending people upgrade.

GHC recently spit back a screenful of errors in response to a function call having an extra argument supplied (that had been refactored away).

That is, the incorrect line was:

action qp = attempt . scope "action" $ (interpretPure <$> term) -- incorrect

And the corrected version was:

Take-home functional programming interview

This document is licensed CC0.

These are some questions to give a sense of what you know about FP. This is more of a gauge of what you know, it's not necessarily expected that a single person will breeze through all questions. For each question, give your answer if you know it, say how long it took you, and say whether it was 'trivial', 'easy', 'medium', 'hard', or 'I don't know'. Give your answers in Haskell for the questions that involve code.

Please be honest, as the interviewer may do some spot checking with similar questions. It's not going to look good if you report a question as being 'trivial' but a similar question completely stumps you.

Here's a bit more guidance on how to use these labels:

	/**
	* In this version of `Traverse`, sequencing always goes through `List` (or some other canonical sequence type),
	* which can be done in a stack-safe manner using a balanced fold as in https://gist.github.com/pchiusano/7667597.
	* It's quite nice that `sequence` and `traverse` are now derived functions.
	*/
	trait Traverse[F[_]] extends Functor[F] {
	/** Inefficient but correct implementation of `toList` in terms of `mapAccumulate`. */
	def toList[A](f: F[A]): List[A] = mapAccumulate(f, List())((a, rbuf) => (a, a :: rbuf))._2.reverse

	/** The only function that must be implemented. Must be consistent with `map`. */

	-- note, syntax here is Unison, just using .hs extension to get some syntax highlighting

	-- The mapping function may spawn subcomputations on different nodes,
	-- and the reduction function is done in parallel, building a balanced tree
	-- of operations. Computation fails if any step takes longer than timeout
	mapreduce : forall a b
	. Duration -> (a -> Remote b) -> b -> (b -> b -> b) -> Vector a
	-> Remote b
	mapreduce timeout f z op vs = do Remote
	futures := Remote.traverse (f `and-then` Remote.start timeout) vs

	<pchiusano> Paul Chiusano hi, I have a question about stream ciphers - how do people usually go about adding tamper resistence? With a stream cipher used naively, the ciphertext could be truncated or otherwise tampered with, and this would not necessarily be detected, right? My first thought was to split plaintext into packets of some length and add a hash to each packet (seems like
	3:39 PM R<Riastradh> Unknown pchiusano: Secret-key authenticators, or secret-key authenticated encryption.
	3:40 PM R<Riastradh> Unknown pchiusano: Secret-key authenticators are also called message authentication codes, MACs. Typical examples are polynomial evaluation one-time authenticators such as Poly1305, and hash-based constructions such as HMAC, or prefix-MAC with modern `hash functions' like BLAKE2 and SHA-3.
	3:40 PM ⇐ viccuad quit (~vic@unaffiliated/viccuad) Ping timeout: 244 seconds
	3:41 PM P<pchiusano> Paul Chiusano Riastradh: why would you prefer one vs the other
	3:42 PM R<Riastradh> Unknown pchiusano: Typical examples

	{-# Language ScopedTypeVariables #-}
	{-# Language BangPatterns #-}
	{-# Language ExistentialQuantification #-}
	{-# Language Rank2Types #-}
	{-# Language GADTs #-}
	module Stream where

	import Control.Applicative
	import Control.Monad

	module Unison.Cryptography where

	import Data.ByteString (ByteString)

	type DoneHandshake = Bool
	type Ciphertext = ByteString

	data Cryptography key symmetricKey signKey signature hash cleartext =
	Cryptography
	-- public key

	module Unison.Runtime.Block where

	import Data.Maybe
	import Data.Bytes.Serial (Serial, serialize, deserialize)
	import Data.ByteString (ByteString)
	import Unison.BlockStore (BlockStore, Series)
	import qualified Unison.BlockStore as BlockStore
	import qualified Data.Bytes.Get as Get
	import qualified Data.Bytes.Put as Put