pete-murphy

module Main where

import Prelude

import Control.Comonad (class Comonad, extend, extract)
import Control.Comonad.Store (Store, store, peek, pos)
import Control.Comonad.Traced (Traced, runTraced, traced)
import Effect (Effect)
import Effect.Class.Console (log)
import Data.Array ((..), filter, length)

pete-murphy

module Main where

import Prelude

import Control.Comonad (class Comonad)
import Control.Comonad as Comonad
import Control.Extend (class Extend)
import Control.Extend as Extend
import Data.Array.NonEmpty (NonEmptyArray)
import Data.Array.NonEmpty as NE

pete-murphy

module Main where

import Prelude
import Effect (Effect)
import Effect.Console as Console
import TryPureScript (render, withConsole)


data SchoolPerson = Teacher | Director | Student String

pete-murphy

module Main where

import Prelude

import Control.Alt ((<|>))
import Control.Lazy as Lazy
import Data.Either (Either(..))
import Data.Int as Int
import Data.Maybe (Maybe(..))
import Effect (Effect)

pete-murphy

module Main where

import Prelude
import Affjax as Affjax
import Affjax.ResponseFormat as ResponseFormat
import Control.Monad.Except (ExceptT(..))
import Control.Monad.Except as Except
import Data.Argonaut as Argonaut
import Effect (Effect)
import Effect.Class as Effect

pete-murphy

module Main where

import Prelude

import Data.Foldable (foldMap, sum)
import Data.List (List)
import Data.List.Lazy (replicate, toUnfoldable)
import Data.Monoid.Additive (Additive(..))
import Data.Newtype (alaF)
import Data.Rational (Ratio, (%))

pete-murphy

module Main where

import Prelude
import Effect (Effect)
import Effect.Class.Console as Console
import Data.Generic.Rep (class Generic)
import Data.Show.Generic as Show.Generic
import Test.QuickCheck.Arbitrary (class Arbitrary)
import Test.QuickCheck.Arbitrary as Arbitrary
import Test.QuickCheck.Gen (Gen)

pete-murphy

import * as L from "./foldl"
import * as RA from "fp-ts/ReadonlyArray"
import * as RNEA from "fp-ts/ReadonlyNonEmptyArray"
import * as T from "fp-ts/Tree"
import { identity, pipe } from "fp-ts/function"

const sum: L.Fold<number, number> = run =>
  run({
    step: (x, y) => x + y,
    init: 0,

pete-murphy

module Main where -- Overwritten by Try PureScript

import Prelude
import Data.Foldable as Foldable
import Data.Maybe (Maybe(..))
import Effect (Effect)
import Effect.Class (class MonadEffect, liftEffect)
import Halogen as H
import Halogen.HTML as HH
import Halogen.Aff as HA

pete-murphy

import fs from "fs"
import { flow, pipe, not } from "fp-ts/function"
import * as Str from "fp-ts/string"
import * as E from "fp-ts/Either"
import * as O from "fp-ts/Option"
import * as RA from "fp-ts/ReadonlyArray"
import * as D from "io-ts/Decoder"

const lines = (str: string): ReadonlyArray<string> => str.split("\n")