Zsolt Szende pwm

This text now lives at https://github.com/MarcDiethelm/contributing/blob/master/README.md. I turned it into a Github repo so you can, you know, contribute to it by making pull requests.

Contributing

If you want to contribute to a project and make it better, your help is very welcome. Contributing is also a great way to learn more about social coding on Github, new technologies and and their ecosystems and how to make constructive, helpful bug reports, feature requests and the noblest of all contributions: a good, clean pull request.

List folds in Haskell from a use case oriented perspective

Since the definitions in Data.Foldable are too generic, here are list-specific ones:

-- foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
foldl :: (b -> a -> b) -> b -> [a] -> b
foldl f z []     = z
foldl f z (x:xs) = let z' = z `f` x
                   in foldl f z' xs

	{-# language BlockArguments, LambdaCase, Strict, UnicodeSyntax #-}

	{-\|
	Minimal dependent lambda caluclus with:
	- HOAS-only representation
	- Lossless printing
	- Bidirectional checking
	- Efficient evaluation & conversion checking

	Inspired by https://gist.github.com/Hirrolot/27e6b02a051df333811a23b97c375196

	type term =
	\| Lam of (term -> term)
	\| Pi of term * (term -> term)
	\| Appl of term * term
	\| Ann of term * term
	\| FreeVar of int
	\| Star
	\| Box

	let unfurl lvl f = f (FreeVar lvl)

	{-# LANGUAGE LambdaCase #-}
	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	{-# LANGUAGE TypeApplications #-}

	module BFS where

	import Control.Applicative
	import Control.Monad.Logic
	import Control.Monad.Reader

	{-# LANGUAGE BlockArguments #-}
	{-# LANGUAGE Rank2Types #-}
	{-# LANGUAGE TypeOperators #-}
	{-# OPTIONS_GHC -Wall -Werror -Wextra -Wno-name-shadowing #-}

	module HyperList where

	import Data.Function ((&))

	newtype a -&> b = Hyp {invoke :: (b -&> a) -> b}

	-- Based on: http://augustss.blogspot.com/2007/10/simpler-easier-in-recent-paper-simply.html
	import Data.List (delete, union)
	{- HLINT ignore "Eta reduce" -}

	-- File mnemonics:
	-- env = typing environment
	-- vid = variable identifier in Bind or Var
	-- br = binder variant (Lambda or Pi)
	-- xyzTyp = type of xyz
	-- body = body of Lambda or Pi abstraction

	{-# LANGUAGE LambdaCase #-}
	{-# LANGUAGE DeriveFunctor #-}
	{-# LANGUAGE DeriveTraversable #-}
	{-# LANGUAGE RankNTypes #-}
	module Recurser where

	import Control.Lens
	import Data.Monoid
	import Data.Foldable
	import Data.Functor.Contravariant

	{-# LANGUAGE MonoLocalBinds #-}
	{-# LANGUAGE UndecidableInstances #-}
	{-# LANGUAGE FlexibleInstances #-}
	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE DeriveAnyClass #-}
	{-# LANGUAGE DuplicateRecordFields #-}
	module MarkerClass where

	import GHC.TypeLits -- for error messages

	[DuckDNS]
	modulepath=/sbin/duckddns
	queryurl=duckDNS.org