John lgastako

Here's a question on using the Unison language.

I wanted to play around with defining APIs for data sources/sinks/feeds etc, but I hit a wall. I don't know how I should define an API in unison without tying down the underlying datatype used to implement it.

As a example, consider the following bit of Haskell.

-- let's ignore for the purposes of this discussion whether this is a wise definition of a stream...
class StreamT s where
 get :: s a -&gt; (a, s a)

Optics By Example Cheat Sheets

The following are appendices from Optics By Example, a comprehensive guide to optics from beginner to advanced! If you like the content below, there's plenty more where that came from; pick up the book!

Operators
Composition Guide
Substitution Guide
Optical Constarints and Types

Operator Cheat Sheet

Monads and delimited control are very closely related, so it isn’t too hard to understand them in terms of one another. From a monadic point of view, the big idea is that if you have the computation m >>= f, then f is m’s continuation. It’s the function that is called with m’s result to continue execution after m returns.

If you have a long chain of binds, the continuation is just the composition of all of them. So, for example, if you have

m >>= f >>= g >>= h

then the continuation of m is f >=> g >=> h. Likewise, the continuation of m >>= f is g >=> h.

	{-# LANGUAGE PatternSynonyms #-}
	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE TemplateHaskell #-}
	{-# LANGUAGE ViewPatterns #-}

	-- \| This module contains some approach for emulating array syntax from
	-- imperative languages. The approach emulates only syntax, not efficiency.
	-- Though if you like working with persistent arrays it may be good for you.
	-- Also it's a fun exercise on lenses.

	{-# LANGUAGE NoImplicitPrelude #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	{-# LANGUAGE OverloadedStrings #-}

	module Main where

	import Protolude
	import qualified Web.Scotty as Sc
	import qualified Data.Text as Txt
	import qualified Network.Wai.Middleware.Gzip as Sc

	data Settings = Settings
	{ settingsFoo :: Int
	, settingsBar :: String
	, settingsBaz :: [Int]
	}
	deriving (stock) Generic

	instance FromJSON Settings where
	parseJSON = parseJSONFielded

	-- in response to https://twitter.com/chrislpenner/status/1221784005156036608
	--
	-- The goal is to mimic this Scala code, but in Haskell:
	--
	-- > "spotify:user:123:playlist:456" match {
	-- > case s"spotify:user:$userId:playlist:$playlistId"
	-- > => ($userId, $playlistId) // ("123", "456")
	-- > }
	{-# LANGUAGE DeriveFunctor, LambdaCase, PatternSynonyms, QuasiQuotes, RankNTypes, TemplateHaskell, TypeOperators, ViewPatterns #-}
	{-# OPTIONS -Wno-name-shadowing #-}

	%default total

	\|\|\| A stream (an infinite list) of natural numbers representing the
	\|\|\| fibbonacci sequence.
	fibs : Stream Nat
	fibs = f 0 1
	where
	f : Nat -> Nat -> Stream Nat
	f a b = a :: f b (a + b)

	{-# LANGUAGE NoImplicitPrelude #-}
	{-# LANGUAGE OverloadedStrings #-}

	module Fizz where

	import Protolude

	fizzBuzz :: IO ()
	fizzBuzz = run fizzBuzzRules

	This is a tutorial on the Curry-Howard correspondence, or the correspondence
	between logic and type theory, written by Keith Pinson, who is still a learner
	on this subject. If you find an error, please let me know.

	This is a Bird-style literate Haskell file. Everything is a comment by default.
	Lines of actual code start with `>`. I recommend that you view it in an editor
	that understands such things (e.g. Emacs with `haskell-mode`). References will
	also be made to Scala, for programmers less familiar with Haskell.

	We will need to turn on some language extensions. This is not an essay on good