michaeljklein

Jens Palsberg: Jones-Optimal Partial Evaluation by Specialization-Safe Normalization

https://popl18.sigplan.org/event/popl-2018-papers-typed-and-jones-optimal-self-applicable-partial-evaluation

Notes.

We can treat unbound or polymorphic variables as unbound variables.

before:

ncthbrt

type permission =
  | Permission(string, string);

module PermissionComparision = {
  type t = permission;
  let compare = (Permission(name1, _), Permission(name2, _)) => String.compare(name1, name2);
};

module PermissionSet = Set.Make(PermissionComparision);

jaredly

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) {

snoyberg

#!/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

phadej

{-# 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

brentvatne

• https://github.com/arnarthor/advent-of-code-2017 (Native & BuckleScript)
• https://github.com/rrdelaney/advent-of-code-2017 (Native)
• https://github.com/fazouane-marouane/advent-of-code-2017 (BuckleScript)
• https://github.com/jaredly/advent-2017 (BuckleScript)
• https://github.com/brentbaum/advent-of-code (BuckleScript)
• https://github.com/Lokeh/advent-2017 (BuckleScript)
• https://github.com/wyze/advent-of-code-2017 (BuckleScript)
• https://github.com/brentvatne/advent-of-code-2017 (BuckleScript)

lilactown

/**
 * 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"));

arianvp

import Control.Monad.IO.Class
import Control.Monad.Codensity
import System.IO


managedActions :: Codensity IO ()
managedActions = do
  input <- Codensity $ withFile "in.txt" ReadMode
  output <- Codensity $ withFile "out.txt" WriteMode
  contents <- liftIO $ hGetContents input

thoughtpolice

{-# OPTIONS_GHC -Wall #-}

{-# LANGUAGE DeriveAnyClass        #-}
{-# LANGUAGE DeriveDataTypeable    #-}
{-# LANGUAGE LambdaCase            #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE PartialTypeSignatures #-}
module RegAlloc1
  ( -- * Types
    Var

chshersh

-- To run: 
--    cabal repl -b pretty-simple
--
-- Colorizing and pretty-printing ghci output
-- requires: pretty-simple
:set -interactive-print=Text.Pretty.Simple.pPrint

-- green bold lambdas and multiline mode
:set prompt      "\ESC[1;32mλ: \ESC[m"
:set prompt-cont "\ESC[1;32mλ| \ESC[m"