juanbono

1. have a brilliant idea for something you want to use
2. Stop! Don't start building it. 
3. Find a project that does something similar. (This likely exists)
4. Read it's documentation. 
  * If it has none, learn the project and create some. 
  * If it does, try to build something with it and document what wasn't clear. 
5. If it feels broke. Write some failing tests, 
  * If possible, fix them, then open a pr
  * If not, open a pr with failing tests and get the maintainer to teach you how to fix them 
6. Document your process for contributing in a file called CONTIBUTING.md

juanbono

type product = {
  category: string,
  price: string,
  stocked: bool,
  name: string
};

type products = list(product);

let products = [

juanbono

type copyOpts;

[@bs.obj] external makeCopyOpts : (~overwrite: bool=?, ~errorOnExist: bool=?, ~dereference: bool=?, ~preserveTimestamps: bool=?, ~filter: (string=>bool)=?, unit) => copyOpts = "";

/* copySync(src, dest, [options]) */
/* https://github.com/jprichardson/node-fs-extra/blob/master/docs/copy-sync.md */
[@bs.module "fs-extra"] external copySyncExternal : (string, string, copyOpts) => unit = "copySync";

let copySync = (~overwrite=?, ~errorOnExist=?, ~dereference=?, ~preserveTimestamps=?, ~filter:option(string => bool)=?,
src: string, dest: string) =>

juanbono

{-# OPTIONS --postfix-projections #-}
module Preorders where

open import Level
open import Data.Unit hiding (_≤_)
open import Data.Product hiding (map)
open import Function hiding (id)
open import Relation.Binary public using (Reflexive; Transitive; Symmetric; _=[_]⇒_)
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_)

juanbono

{-# LANGUAGE GADTs, TypeFamilies, EmptyDataDecls #-}

{-

A Haskell-based implementation of the monadic semantics for the
simply-typed Call-By-Name computational lambda calculus, following
Moggi's 'Computational lambda-calculus and monads' (1989) (technical report version)
but for the typed calculus (rather than untyped as in this paper).

Category theory seminar, Programming Languages and Systems group,

juanbono

let recv = (client, maxlen) => {
  let bytes = Bytes.create(maxlen);
  let len = Unix.recv(client, bytes, 0, maxlen, []);
  Bytes.sub_string(bytes, 0, len)
};

let parse_top = top => {
  let parts = Str.split(Str.regexp("[ \t]+"), top);
  switch (parts) {

juanbono

2016

1. Sixth Summer School on Formal Techniques / 22-27 May
2. Twelfth International Summer School on Advanced Computer Architecture and Compilation for High-Performance and Embedded Systems / 10-16 July 2016
3. Oregon Programming Languages Summer School / 20 June-2 July 2016
4. The 6th Halmstad Summer School on Testing / 13-16 June, 2016
5. Second International Summer School on Behavioural Types / 27 June-1 July 2016
6. Virtual Machines Summer School 2016 / 31 May - 3 June 2016
7. ECOOP 2016 Summer School

2015

juanbono

#!/usr/bin/env stack
-- stack --resolver lts-10.0 script
{-# LANGUAGE OverloadedStrings #-}
import Text.XML
import qualified Data.Map.Strict as Map

main :: IO ()
main = do
  Document x (Element n a nodes) y <- Text.XML.readFile def "foo.html"
  Text.XML.writeFile def "foo2.html" $ Document x (Element n a $ concatMap goN nodes) y

juanbono

/**
 * Making promises
 */
let okPromise = Js.Promise.make((~resolve, ~reject as _) => [@bs] resolve("ok"));

/* Simpler promise creation for static values */
Js.Promise.resolve("easy");

Js.Promise.reject(Invalid_argument("too easy"));

juanbono

{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE OverloadedStrings #-}
module Main where

import Data.Foldable (for_)
import Data.Traversable (for)
import Control.Monad.IO.Class

-- build-depends: base, haskeline, optparse-applicative
-- -- for example parser