Ahnfelt

# This is an implementation of Software Transactional Memory.
# The idea is that when a variable is first used in an atomic block,
# we save a snapshot of its current value and version.
# When we reach the end of the transaction, we lock all variables 
# that have been read or written to inside the atomic block. If any
# of the variables we read has been changed from the outside, we 
# reset the transaction and rerun it from the beginning. Otherwise
# we write the new values back into the shared memory with a new 
# version. For each variable, we maintain information on what other
# variables have been updated to what versions at the same time,

Ahnfelt

// System.OpenCL.Private.Synchronization:

module System.OpenCL.Private.Synchronization (
  enqueueMarker, enqueueBarrier, enqueueWaitForEvents, waitForEvents
  ) where

// [..snip..]

waitForEvents :: [Event] -> IO ()
waitForEvents events =

Ahnfelt

data Sound
    = Silence
    | Audio AudioData
    | Volume Double Sound
    | Sequence Sound Sound

data SoundM a = SoundM Sound a

instance Monad SoundM where
    return a = SoundM Silence a

Ahnfelt

    public void writeTag(int tag) throws SerializationException {
        try {
            if(tag < 128) {
                stream.writeByte(tag - 128);
            } else {
                stream.writeInt(tag);
            }
        } catch(IOException e) {
            throw new SerializationException(e);
        }

Ahnfelt

package com.infopaq.research.flow.common;

import java.util.Arrays;

public class ByteId {
    private final byte[] bytes;

    public ByteId(byte[] bytes) {
        this.bytes = bytes;
    }

Ahnfelt

{-

	This code parses a subset of JavaScript and detects usages of undeclared variables.
	
	It's an example of a Parsec parser; it's by no means complete.
	This source code primarily uses the do-syntax for writing the parser, 
	but that's not the only way to write code with Parsec.
	This code was written in a hurry by Joakim Ahnfelt-Rønne during the meetup at 2014-21-10.
	
	USAGE:

Ahnfelt

interface ShopService {
    void buy();
    void sell();
}

interface DatabaseService {
    void beginTransaction();
    void commit();
    void abort();
}

Ahnfelt

;;;;;;;;;;
; Prelude
;;;;;;;;;;

if := {
    |True body _| body()
    |False _ body| body()
}

when := {

Ahnfelt

// WIP, untested attachable. A sort of generalized loader that should support infinite scroll and more.
// Example:
//  val requester = Requester(this, Signal(1)) { (old, pageNumber) =>
//      fetchPage(pageNumber).map(_ ++ old.toList.flatten)
//  }
// Later, request page 2:
//  requester.request(2)


import com.github.ahnfelt.react4s.Loader.{Loaded, Loading, Result, Error}

Ahnfelt

html <- Http.fetchJson {url: "https://reqres.in/api/users?page=2"}

people : List {id: Int, "first_name": String, "last_name": String, avatar: String} = 
    Json.toAny html.data

htmlImage = url -> Html.tag "img" [Html.attribute "src" url]

peopleWithImages = people |> List.map (
    p -> {image: htmlImage p.avatar, name: p."first_name" + " " + p."last_name"}
)