LivewareIssue

quicksort :: Ord a => [a] -> [a]
quicksort = quicksortBy compare

quicksortBy :: (a -> a -> Ordering) -> [a] -> [a]
quicksortBy _ [] = []
quicksortBy _ [x] = [x]
quicksortBy cmp xs = (quicksortBy cmp lo) ++ [pivot] ++ (quicksortBy cmp hi)  where
    (pivot, (lo, hi)) = partitionBy cmp xs

partitionBy :: (a -> a -> Ordering) -> [a] -> (a, ([a], [a]))

LivewareIssue

data Tree a = Empty | Node a [Tree a]
  deriving Show

dft :: Tree a -> [a]
dft Empty = []
dft (Node x xs) = x:(concatMap dft xs)

bft :: Tree a -> [a]
bft Empty = []
bft (Node x xs) = x:(catMaybes $ map value xs) ++ (concatMap bft (concatMap children xs))

LivewareIssue

mergeBy :: (a -> a -> Ordering) -> [a] -> [a] -> [a]
mergeBy _ [] [] = []
mergeBy _ xs [] = xs
mergeBy _ [] ys = ys
mergeBy cmp xs@(x:xs') ys@(y:ys')
  | cmp x y <= EQ = x:(mergeBy cmp xs' ys)
  | otherwise = y:(mergeBy cmp xs ys')

merge :: Ord a => [a] -> [a] -> [a]
merge = mergeBy compare

LivewareIssue

mergeBy :: (a -> a -> Ordering) -> [a] -> [a] -> [a]
mergeBy _ [] [] = []
mergeBy _ xs [] = xs
mergeBy _ [] ys = ys
mergeBy cmp xs@(x:xs') ys@(y:ys')
  | cmp x y <= EQ = x:(mergeBy cmp xs' ys)
  | otherwise = y:(mergeBy cmp xs ys')

merge :: Ord a => [a] -> [a] -> [a]
merge = mergeBy compare

LivewareIssue

mergeBy :: (a -> a -> Ordering) -> [a] -> [a] -> [a]
mergeBy _ [] [] = []
mergeBy _ xs [] = xs
mergeBy _ [] ys = ys
mergeBy cmp xs@(x:xs') ys@(y:ys')
  | cmp x y <= EQ = x:(mergeBy cmp xs' ys)
  | otherwise = y:(mergeBy cmp xs ys')

merge :: Ord a => [a] -> [a] -> [a]
merge = mergeBy compare

LivewareIssue

import Test.QuickCheck
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Ord (comparing)
import Data.List (sortBy, maximumBy)

main :: Int -> IO ()
main n = do
    lifespans <- generate $ arbitrary_lifespans n
    print $ maximumPopulationYear lifespans

LivewareIssue

data Edge a b = Edge { source ∷ a, sink ∷ a, label ∷ b }
    deriving (Eq, Show)

-- Directed, edge-labelled graph represented as an adjacency list
type Graph a b = [(a, [Edge a b])]

-- A path is a contigious sequence of edges 
type Path a b = [Edge a b]

-- Get all the edges of a graph

LivewareIssue

Imports System.Data.Entity.Design.PluralizationServices
Imports System.Globalization
Imports System.Runtime.CompilerServices
Imports Sprache

Public Module Program
    Public Sub Main(args As String())
        Dim identifier = "Sage200HTMLPerson"

        PascalCase.ToKebabCase("FooBaa")

LivewareIssue

SELECT
	ColumName = col.name,
	DataType = typ.name,
	[Precision] = col.precision,
	[Scale] = col.scale,
	[MaxLength] = col.max_length,
	IsPrimaryKey = ISNULL(ix.is_primary_key, 0),
	ReferencedTableName = tbl.name,
	ReferencedColumnName = refcol.name
FROM

LivewareIssue

{-# LANGUAGE PolyKinds, PartialTypeSignatures #-}

module GameOfLife where

    import Control.Comonad (extract, extend)
    import Control.Comonad.Representable.Store (Store, peek, store, experiment)
    import Data.Functor.Rep (Rep, index)
    import Data.Finite (Finite, strengthen, shift, unshift, weaken)
    import Data.Functor.Compose (Compose)
    import GHC.TypeLits (Nat, KnownNat, type (<=))