CarstenKoenig

### Keybase proof

I hereby claim:

  * I am carstenkoenig on github.
  * I am carstenkoenig (https://keybase.io/carstenkoenig) on keybase.
  * I have a public key whose fingerprint is BB93 DA5D BF8A 3E50 2EF7  F595 E68E DE6B D673 43C5

To claim this, I am signing this object:

CarstenKoenig

let seqInnerJoin predicate seq1 seq2 =
    let findPairs predicate seq2 element1 =
        seq2
        |> Seq.where (predicate element1)
        |> Seq.map (fun element2 -> element1, element2)
    seq1
    |> Seq.map (findPairs predicate seq2)
    |> Seq.collect (fun pair -> pair)
    
    

CarstenKoenig

// Die Frage war, warum
["1", "5"].map(parseInt);
// schief geht.

// Johannes hatte die Antwort, die ich nicht vertanden habe
// die Konsole hilft weiter:

var f = function() { console.log(arguments); }
["1", "5"].map(f)
> ["1", 0, Array[2]]

CarstenKoenig

module Vigenere where

import Data.Char
import Test.QuickCheck.Test (quickCheck)

encrypt :: String -> String -> String
encrypt key = zipWith (shiftChar (+)) (cycle key)

decrypt :: String -> String -> String
decrypt key = zipWith (shiftChar (flip (-))) (cycle key)

CarstenKoenig

import Data.Maybe (fromJust)
import Data.List (sort)

rankList :: [Int] -> [Int]
rankList ns = map (fromJust . (flip lookup) ranks) ns
   where ranks = zipWith (flip (,)) [1..] . sort $ ns

CarstenKoenig

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE OverloadedStrings #-}

module Main where

import GHC.Exts (sortWith)

import Data.Function (on)
import Data.List (maximumBy, sortBy, nub, foldl')
import qualified Data.Map.Strict as M

CarstenKoenig

namespace EventSourcing

module View =
 
    /// the View's builder-type - includes bookkepping for intermediate types and should be hidden
    /// from (poor) users view
    type T<'e,'i,'a> = private { foldF : 'i -> 'e  -> 'i; project : 'i -> 'a; init : 'i }
 
    /// creates a view, based on a fold over intermediate values and a final projection
    let createWithProjection (p : 'i -> 'a) (i : 'i) (f : 'i -> 'e -> 'i) =

CarstenKoenig

diagInd :: [(Integer, Integer)]
diagInd = iterate f (1,1)
  where f (lx,ly)
          | ly == 1 = (1, lx+1)
          | otherwise = (lx+1, ly-1)

CarstenKoenig

Klonen von Github (inkl. Submodulen)

git clone https://github.com/mono/monodevelop.git
cd monodevelop
git submodule update --init --recursive

Das dauert eine Weile....

Konfigurieren

CarstenKoenig

    let zipAsync (a : Async<'a>) (b : Async<'b>) : Async<'a * 'b> =
        async {
            let! a' = Async.StartChild a
            let! b' = Async.StartChild b
            let! a'' = a'
            let! b'' = b'
            return (a'',b'')
        }