mattpodwysocki

#light

[<AutoOpen>]
module Operators =
  let (||>) (x, y) f = f x y

module Map =
  let transposeCombine m =
    (Map.empty, m) ||> Map.fold_left (fun acc k1 m' ->
      (acc, m') ||> Map.fold_left (fun acc' k2 v ->

mattpodwysocki

#light
 
[<AutoOpen>]
module Operators =
  let (||>) (x, y) f = f x y
 
module Map =
  let transposeCombine m =
    (m, m) ||> Map.fold_left (fun acc k1 m' ->
      (acc, m') ||> Map.fold_left (fun acc' k2 v ->

mattpodwysocki

#light

[<AutoOpen>]
module Operators =
  // Untuple forward operator
  let (||>) (x,y) f = f x y

module Map =
  let union m1 m2 =
    (m1, m2) ||> Map.fold_right Map.add

mattpodwysocki

#light

[<AutoOpen>]
module Operators =
  let (||>) (x,y) f = f x y

module Map =
                
  let union m1 m2 =
    (m1, m2) ||> Map.fold_right Map.add

mattpodwysocki

import Data.Map((!), intersection, fromList, keys, Map(..))
import Data.List(sort)

type Preferences = Map String (Map String Double)
type Similarity = Preferences -> String -> String -> Double

critics :: Preferences
critics = fromList [
  ("Lisa Rose", fromList
    [("Lady in the Water" , 2.5),

mattpodwysocki

import Data.Map(Map(..), (!), empty, findWithDefault, foldWithKey, fromList, insert)
import Data.Map as M

data City = Boise 
          | LosAngeles 
          | NewYork 
          | Seattle
          | StLouis 
          | Phoenix 
          | Boston 

mattpodwysocki

public static class FuncExtensions
{
    public static Func<TArg2, TResult> Apply<TArg1, TArg2, TResult>(
        this Func<TArg1, TArg2, TResult> function, TArg1 x)
    {
        return y => function(x, y);
    }

    public static Func<TSource, TResult> Compose<TSource, TIntermediate, TResult>(
        this Func<TSource, TIntermediate> f1, Func<TIntermediate, TResult> f2)

mattpodwysocki

public static class FuncExtensions
{
    public static Func<TArg1, Func<TArg2, TResult>> Curry<TArg1, TArg2, TResult>(
        this Func<TArg1, TArg2, TResult> func)
    {
        return arg1 => arg2 => func(arg1, arg2);
    }

    public static Func<TArg2, TResult> Apply<TArg1, TArg2, TResult>(
        this Func<TArg1, TArg2, TResult> func, TArg1 arg1)

mattpodwysocki

import Data.Map((!), empty, fromList, filterWithKey, foldWithKey, insertWith, intersection, keys, notMember, toList, Map(..))
import Data.List(sort)

type Preferences = Map String (Map String Double)
type Similarity = Preferences -> String -> String -> Double

critics :: Preferences
critics = fromList [
  ("Lisa Rose", fromList
    [("Lady in the Water" , 2.5),

mattpodwysocki

// Standard Factorial
let rec (!!) = function
  | 1 -> 1
  | x -> x * (!!) (x - 1)

(3!!) // Doesn't work

-- Haskell version does
(!) :: Int -> Int
(!) 1 = 1