Dierk

// Either type in Groovy as a special implementation of the generic sum type
// see: Phil Wadler at LambdaWorld 2016: youtu.be/V10hzjgoklA


import java.util.function.*
import groovy.transform.*

interface Either<A,B> {
    public <C> C match (Function <A,C> leftCase, Function <B,C> rightCase)
}

Dierk

import static groovyx.javafx.GroovyFX.start

/**
 Demo of using methods to create multiple nodes (here Buttons) as a composite view and use those
 factory methods multiple times.
 @author Dierk Koenig
 */

start {
    sgb = delegate

Dierk

module Ants where

import STM

import Control.Concurrent (forkIO, forkOS)

import Data.List (!!, nub, sortBy)

import System.Random

Dierk

import * as React from "react";

export interface HelloProps { compiler: string; framework: string; }
export interface HelloState { slices: number; table: number }

export class Hello extends React.Component<HelloProps, HelloState> {

    constructor(props: HelloProps) {
        super(props);
        this.state = { slices:10, table:2 }

Dierk

import Html exposing (Html, button, div, text)
import Html.App as App
import Html.Events exposing (onClick)
import Svg exposing (svg, circle, line)
import Svg.Attributes exposing (..)
import List exposing (map, (::))


main =
  App.beginnerProgram { model = state, view = view, update = update }

Dierk

module App.Counter where

import Prelude (($), (+), (-), (*), (/), (>), const, show)
import Data.Array ((..), (:), mapWithIndex)
import Data.Int (toNumber, floor)
import Math (sin, cos, pi )
import Pux.Html (Html, div, span, button, text, canvas, svg, circle, line )
import Pux.Html.Attributes (width, height, viewBox, cx, cy, r, fill, x1, y1, x2, y2, stroke, strokeWidth)
import Pux.Html.Events (onClick)

Dierk

module Main where

import Control.Monad.Eff.Console (log)
import Data.List.Lazy (take, zipWith, fromFoldable, cycle, iterate, foldr)
import Data.Monoid (mempty, (<>))
import Data.Maybe (Maybe(..), fromMaybe)

import Prelude ( show, map, ($), (+))

main = do

Dierk

// Haskell-style iterate function in Groovy

Closure iterate(def value, Closure nextValue) {
    return { value = nextValue value }
}


// use for iteration
def iter = iterate(0) { it + 1}

Dierk

import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class RNG {
    static Supplier<Integer> countGen(AtomicInteger i) {
        return (()-> i.getAndIncrement());
    }

Dierk

module SillyClock where

import STM
import Control.Concurrent

type Counter = TVar Int

newCounter :: STM Counter
newCounter = TVar.new 0