owickstrom

#include <iostream>
#include <curl/curl.h>
#include <math.h>
#include <vector>
#include <future>
#include <boost/format.hpp>

#define logbase(a, b) (log(a)/log(b))

using namespace std;

owickstrom

# Ignore dot-files, except the .gitignore file.
.*
!.gitignore
  
# (All rules from CSharp.gitignore)

owickstrom

module WebCheck.PureScript.TodoMVC where

import WebCheck.DSL

import Data.Array (filter, foldMap, head, last, zip)
import Data.Foldable (length)
import Data.Int as Int
import Data.Maybe (Maybe(..), fromMaybe)
import Data.String (Pattern(..), split, trim)
import Data.Tuple (Tuple(..))

owickstrom

Selective Applicative Functors in WebCheck

WebCheck uses a version of PureScript for specifications in testing web applications, which I'll refer to as "the language" in this document.

A specification includes a top-level definition called proposition, which must be a pure expression of type Boolean. The interpreter of the language does not allow effects (the Effect type in PureScript, formerly known as Eff). But there are a few built-in constructs that are at least backed by non-pure computations:

owickstrom

Contributor Agreement

Individual Contributor exclusive License Agreement

(including the Traditional Patent License OPTION)

Thank you for your interest in contributing to Oskar Wickström's Quickstrom ("We" or "Us").

The purpose of this contributor agreement ("Agreement") is to clarify and document the rights granted by contributors to Us.

owickstrom

defmodule State.Counter do
  use GenServer

  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, :ok, opts)
  end

  ## Client API

  @doc "Gets the counter's current value."

owickstrom

{-# OPTIONS_GHC -Wno-missing-methods #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
module ThoughtLeaderTom where

import Control.Monad ((>=>))

owickstrom

// If we have a Person class like this...

case class Person(firstName : String, lastName : String)

// ... and we want to use pattern matching to ensure
// an object is a Person with lastName "Jones" before
// send it to someFunction, we could do something like 
// this:

someObject match {

owickstrom

{-# LANGUAGE DataKinds        #-}
{-# LANGUAGE DeriveGeneric    #-}
{-# LANGUAGE NamedFieldPuns   #-}
{-# LANGUAGE TypeApplications #-}
module HiggledyHedgehog where

import           Control.Lens
import           Data.Generic.HKD
import           GHC.Generics     (Generic)
import           Hedgehog

owickstrom

-- | This shows a way of computing a recursive type, and applying
-- constraints to individual types within it, using a type family.
-- I've commented the different parts, and the file ends with some
-- questions.

{-# LANGUAGE ConstraintKinds      #-}
{-# LANGUAGE DataKinds            #-}
{-# LANGUAGE GADTs                #-}
{-# LANGUAGE KindSignatures       #-}
{-# LANGUAGE RankNTypes           #-}